date_collected
stringclasses 1
value | repo_name
stringlengths 6
116
| file_name
stringlengths 2
220
| file_contents
stringlengths 13
357k
| prompts
sequence |
|---|---|---|---|---|
2024-01-10 | axgpt/langchain | libs~langchain~langchain~llms~vllm.py | from typing import Any, Dict, List, Optional
from langchain_core.pydantic_v1 import Field, root_validator
from langchain_core.schema.output import Generation, LLMResult
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.llms.base import BaseLLM
from langchain.llms.openai import BaseOpenAI
from langchain.utils.openai import is_openai_v1
class VLLM(BaseLLM):
"""VLLM language model."""
model: str = ""
"""The name or path of a HuggingFace Transformers model."""
tensor_parallel_size: Optional[int] = 1
"""The number of GPUs to use for distributed execution with tensor parallelism."""
trust_remote_code: Optional[bool] = False
"""Trust remote code (e.g., from HuggingFace) when downloading the model
and tokenizer."""
n: int = 1
"""Number of output sequences to return for the given prompt."""
best_of: Optional[int] = None
"""Number of output sequences that are generated from the prompt."""
presence_penalty: float = 0.0
"""Float that penalizes new tokens based on whether they appear in the
generated text so far"""
frequency_penalty: float = 0.0
"""Float that penalizes new tokens based on their frequency in the
generated text so far"""
temperature: float = 1.0
"""Float that controls the randomness of the sampling."""
top_p: float = 1.0
"""Float that controls the cumulative probability of the top tokens to consider."""
top_k: int = -1
"""Integer that controls the number of top tokens to consider."""
use_beam_search: bool = False
"""Whether to use beam search instead of sampling."""
stop: Optional[List[str]] = None
"""List of strings that stop the generation when they are generated."""
ignore_eos: bool = False
"""Whether to ignore the EOS token and continue generating tokens after
the EOS token is generated."""
max_new_tokens: int = 512
"""Maximum number of tokens to generate per output sequence."""
logprobs: Optional[int] = None
"""Number of log probabilities to return per output token."""
dtype: str = "auto"
"""The data type for the model weights and activations."""
download_dir: Optional[str] = None
"""Directory to download and load the weights. (Default to the default
cache dir of huggingface)"""
vllm_kwargs: Dict[str, Any] = Field(default_factory=dict)
"""Holds any model parameters valid for `vllm.LLM` call not explicitly specified."""
client: Any #: :meta private:
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that python package exists in environment."""
try:
from vllm import LLM as VLLModel
except ImportError:
raise ImportError(
"Could not import vllm python package. "
"Please install it with `pip install vllm`."
)
values["client"] = VLLModel(
model=values["model"],
tensor_parallel_size=values["tensor_parallel_size"],
trust_remote_code=values["trust_remote_code"],
dtype=values["dtype"],
download_dir=values["download_dir"],
**values["vllm_kwargs"],
)
return values
@property
def _default_params(self) -> Dict[str, Any]:
"""Get the default parameters for calling vllm."""
return {
"n": self.n,
"best_of": self.best_of,
"max_tokens": self.max_new_tokens,
"top_k": self.top_k,
"top_p": self.top_p,
"temperature": self.temperature,
"presence_penalty": self.presence_penalty,
"frequency_penalty": self.frequency_penalty,
"stop": self.stop,
"ignore_eos": self.ignore_eos,
"use_beam_search": self.use_beam_search,
"logprobs": self.logprobs,
}
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
from vllm import SamplingParams
# build sampling parameters
params = {**self._default_params, **kwargs, "stop": stop}
sampling_params = SamplingParams(**params)
# call the model
outputs = self.client.generate(prompts, sampling_params)
generations = []
for output in outputs:
text = output.outputs[0].text
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
@property
def _llm_type(self) -> str:
"""Return type of llm."""
return "vllm"
class VLLMOpenAI(BaseOpenAI):
"""vLLM OpenAI-compatible API client"""
@property
def _invocation_params(self) -> Dict[str, Any]:
"""Get the parameters used to invoke the model."""
params: Dict[str, Any] = {
"model": self.model_name,
**self._default_params,
"logit_bias": None,
}
if not is_openai_v1():
params.update(
{
"api_key": self.openai_api_key,
"api_base": self.openai_api_base,
}
)
return params
@property
def _llm_type(self) -> str:
"""Return type of llm."""
return "vllm-openai"
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~tests~unit_tests~indexes~test_indexing.py | from datetime import datetime
from typing import (
Any,
AsyncIterator,
Dict,
Iterable,
Iterator,
List,
Optional,
Sequence,
Type,
)
from unittest.mock import patch
import pytest
import pytest_asyncio
from langchain_core.schema import Document
from langchain_core.schema.vectorstore import VST, VectorStore
import langchain.vectorstores
from langchain.document_loaders.base import BaseLoader
from langchain.embeddings.base import Embeddings
from langchain.indexes import aindex, index
from langchain.indexes._api import _abatch
from langchain.indexes._sql_record_manager import SQLRecordManager
class ToyLoader(BaseLoader):
"""Toy loader that always returns the same documents."""
def __init__(self, documents: Sequence[Document]) -> None:
"""Initialize with the documents to return."""
self.documents = documents
def lazy_load(
self,
) -> Iterator[Document]:
yield from self.documents
def load(self) -> List[Document]:
"""Load the documents from the source."""
return list(self.lazy_load())
async def alazy_load(
self,
) -> AsyncIterator[Document]:
async def async_generator() -> AsyncIterator[Document]:
for document in self.documents:
yield document
return async_generator()
async def aload(self) -> List[Document]:
"""Load the documents from the source."""
return [doc async for doc in await self.alazy_load()]
class InMemoryVectorStore(VectorStore):
"""In-memory implementation of VectorStore using a dictionary."""
def __init__(self) -> None:
"""Vector store interface for testing things in memory."""
self.store: Dict[str, Document] = {}
def delete(self, ids: Optional[Sequence[str]] = None, **kwargs: Any) -> None:
"""Delete the given documents from the store using their IDs."""
if ids:
for _id in ids:
self.store.pop(_id, None)
async def adelete(self, ids: Optional[Sequence[str]] = None, **kwargs: Any) -> None:
"""Delete the given documents from the store using their IDs."""
if ids:
for _id in ids:
self.store.pop(_id, None)
def add_documents( # type: ignore
self,
documents: Sequence[Document],
*,
ids: Optional[Sequence[str]] = None,
**kwargs: Any,
) -> None:
"""Add the given documents to the store (insert behavior)."""
if ids and len(ids) != len(documents):
raise ValueError(
f"Expected {len(ids)} ids, got {len(documents)} documents."
)
if not ids:
raise NotImplementedError("This is not implemented yet.")
for _id, document in zip(ids, documents):
if _id in self.store:
raise ValueError(
f"Document with uid {_id} already exists in the store."
)
self.store[_id] = document
async def aadd_documents(
self,
documents: Sequence[Document],
*,
ids: Optional[Sequence[str]] = None,
**kwargs: Any,
) -> List[str]:
if ids and len(ids) != len(documents):
raise ValueError(
f"Expected {len(ids)} ids, got {len(documents)} documents."
)
if not ids:
raise NotImplementedError("This is not implemented yet.")
for _id, document in zip(ids, documents):
if _id in self.store:
raise ValueError(
f"Document with uid {_id} already exists in the store."
)
self.store[_id] = document
return list(ids)
def add_texts(
self,
texts: Iterable[str],
metadatas: Optional[List[Dict[Any, Any]]] = None,
**kwargs: Any,
) -> List[str]:
"""Add the given texts to the store (insert behavior)."""
raise NotImplementedError()
@classmethod
def from_texts(
cls: Type[VST],
texts: List[str],
embedding: Embeddings,
metadatas: Optional[List[Dict[Any, Any]]] = None,
**kwargs: Any,
) -> VST:
"""Create a vector store from a list of texts."""
raise NotImplementedError()
def similarity_search(
self, query: str, k: int = 4, **kwargs: Any
) -> List[Document]:
"""Find the most similar documents to the given query."""
raise NotImplementedError()
@pytest.fixture
def record_manager() -> SQLRecordManager:
"""Timestamped set fixture."""
record_manager = SQLRecordManager("kittens", db_url="sqlite:///:memory:")
record_manager.create_schema()
return record_manager
@pytest_asyncio.fixture # type: ignore
@pytest.mark.requires("aiosqlite")
async def arecord_manager() -> SQLRecordManager:
"""Timestamped set fixture."""
record_manager = SQLRecordManager(
"kittens",
db_url="sqlite+aiosqlite:///:memory:",
async_mode=True,
)
await record_manager.acreate_schema()
return record_manager
@pytest.fixture
def vector_store() -> InMemoryVectorStore:
"""Vector store fixture."""
return InMemoryVectorStore()
def test_indexing_same_content(
record_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Indexing some content to confirm it gets added only once."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
),
Document(
page_content="This is another document.",
),
]
)
assert index(loader, record_manager, vector_store) == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
assert len(list(vector_store.store)) == 2
for _ in range(2):
# Run the indexing again
assert index(loader, record_manager, vector_store) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_aindexing_same_content(
arecord_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Indexing some content to confirm it gets added only once."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
),
Document(
page_content="This is another document.",
),
]
)
assert await aindex(await loader.alazy_load(), arecord_manager, vector_store) == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
assert len(list(vector_store.store)) == 2
for _ in range(2):
# Run the indexing again
assert await aindex(
await loader.alazy_load(), arecord_manager, vector_store
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
def test_index_simple_delete_full(
record_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Indexing some content to confirm it gets added only once."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
),
Document(
page_content="This is another document.",
),
]
)
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 1).timestamp()
):
assert index(loader, record_manager, vector_store, cleanup="full") == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 1).timestamp()
):
assert index(loader, record_manager, vector_store, cleanup="full") == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
loader = ToyLoader(
documents=[
Document(
page_content="mutated document 1",
),
Document(
page_content="This is another document.", # <-- Same as original
),
]
)
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert index(loader, record_manager, vector_store, cleanup="full") == {
"num_added": 1,
"num_deleted": 1,
"num_skipped": 1,
"num_updated": 0,
}
doc_texts = set(
# Ignoring type since doc should be in the store and not a None
vector_store.store.get(uid).page_content # type: ignore
for uid in vector_store.store
)
assert doc_texts == {"mutated document 1", "This is another document."}
# Attempt to index again verify that nothing changes
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert index(loader, record_manager, vector_store, cleanup="full") == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_aindex_simple_delete_full(
arecord_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Indexing some content to confirm it gets added only once."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
),
Document(
page_content="This is another document.",
),
]
)
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 1).timestamp()
):
assert await aindex(
await loader.alazy_load(), arecord_manager, vector_store, cleanup="full"
) == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 1).timestamp()
):
assert await aindex(
await loader.alazy_load(), arecord_manager, vector_store, cleanup="full"
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
loader = ToyLoader(
documents=[
Document(
page_content="mutated document 1",
),
Document(
page_content="This is another document.", # <-- Same as original
),
]
)
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert await aindex(
await loader.alazy_load(), arecord_manager, vector_store, cleanup="full"
) == {
"num_added": 1,
"num_deleted": 1,
"num_skipped": 1,
"num_updated": 0,
}
doc_texts = set(
# Ignoring type since doc should be in the store and not a None
vector_store.store.get(uid).page_content # type: ignore
for uid in vector_store.store
)
assert doc_texts == {"mutated document 1", "This is another document."}
# Attempt to index again verify that nothing changes
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert await aindex(
await loader.alazy_load(), arecord_manager, vector_store, cleanup="full"
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
def test_incremental_fails_with_bad_source_ids(
record_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Test indexing with incremental deletion strategy."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
Document(
page_content="This is yet another document.",
metadata={"source": None},
),
]
)
with pytest.raises(ValueError):
# Should raise an error because no source id function was specified
index(loader, record_manager, vector_store, cleanup="incremental")
with pytest.raises(ValueError):
# Should raise an error because no source id function was specified
index(
loader,
record_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
)
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_aincremental_fails_with_bad_source_ids(
arecord_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Test indexing with incremental deletion strategy."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
Document(
page_content="This is yet another document.",
metadata={"source": None},
),
]
)
with pytest.raises(ValueError):
# Should raise an error because no source id function was specified
await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup="incremental",
)
with pytest.raises(ValueError):
# Should raise an error because no source id function was specified
await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
)
def test_no_delete(
record_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Test indexing without a deletion strategy."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
]
)
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert index(
loader,
record_manager,
vector_store,
cleanup=None,
source_id_key="source",
) == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
# If we add the same content twice it should be skipped
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert index(
loader,
record_manager,
vector_store,
cleanup=None,
source_id_key="source",
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
loader = ToyLoader(
documents=[
Document(
page_content="mutated content",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
]
)
# Should result in no updates or deletions!
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert index(
loader,
record_manager,
vector_store,
cleanup=None,
source_id_key="source",
) == {
"num_added": 1,
"num_deleted": 0,
"num_skipped": 1,
"num_updated": 0,
}
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_ano_delete(
arecord_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Test indexing without a deletion strategy."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
]
)
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup=None,
source_id_key="source",
) == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
# If we add the same content twice it should be skipped
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup=None,
source_id_key="source",
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
loader = ToyLoader(
documents=[
Document(
page_content="mutated content",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
]
)
# Should result in no updates or deletions!
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup=None,
source_id_key="source",
) == {
"num_added": 1,
"num_deleted": 0,
"num_skipped": 1,
"num_updated": 0,
}
def test_incremental_delete(
record_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Test indexing with incremental deletion strategy."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
]
)
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert index(
loader,
record_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
) == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
doc_texts = set(
# Ignoring type since doc should be in the store and not a None
vector_store.store.get(uid).page_content # type: ignore
for uid in vector_store.store
)
assert doc_texts == {"This is another document.", "This is a test document."}
# Attempt to index again verify that nothing changes
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert index(
loader,
record_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
# Create 2 documents from the same source all with mutated content
loader = ToyLoader(
documents=[
Document(
page_content="mutated document 1",
metadata={"source": "1"},
),
Document(
page_content="mutated document 2",
metadata={"source": "1"},
),
Document(
page_content="This is another document.", # <-- Same as original
metadata={"source": "2"},
),
]
)
# Attempt to index again verify that nothing changes
with patch.object(
record_manager, "get_time", return_value=datetime(2021, 1, 3).timestamp()
):
assert index(
loader,
record_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
) == {
"num_added": 2,
"num_deleted": 1,
"num_skipped": 1,
"num_updated": 0,
}
doc_texts = set(
# Ignoring type since doc should be in the store and not a None
vector_store.store.get(uid).page_content # type: ignore
for uid in vector_store.store
)
assert doc_texts == {
"mutated document 1",
"mutated document 2",
"This is another document.",
}
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_aincremental_delete(
arecord_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Test indexing with incremental deletion strategy."""
loader = ToyLoader(
documents=[
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is another document.",
metadata={"source": "2"},
),
]
)
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
) == {
"num_added": 2,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
doc_texts = set(
# Ignoring type since doc should be in the store and not a None
vector_store.store.get(uid).page_content # type: ignore
for uid in vector_store.store
)
assert doc_texts == {"This is another document.", "This is a test document."}
# Attempt to index again verify that nothing changes
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 2).timestamp()
):
assert await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 2,
"num_updated": 0,
}
# Create 2 documents from the same source all with mutated content
loader = ToyLoader(
documents=[
Document(
page_content="mutated document 1",
metadata={"source": "1"},
),
Document(
page_content="mutated document 2",
metadata={"source": "1"},
),
Document(
page_content="This is another document.", # <-- Same as original
metadata={"source": "2"},
),
]
)
# Attempt to index again verify that nothing changes
with patch.object(
arecord_manager, "aget_time", return_value=datetime(2021, 1, 3).timestamp()
):
assert await aindex(
await loader.alazy_load(),
arecord_manager,
vector_store,
cleanup="incremental",
source_id_key="source",
) == {
"num_added": 2,
"num_deleted": 1,
"num_skipped": 1,
"num_updated": 0,
}
doc_texts = set(
# Ignoring type since doc should be in the store and not a None
vector_store.store.get(uid).page_content # type: ignore
for uid in vector_store.store
)
assert doc_texts == {
"mutated document 1",
"mutated document 2",
"This is another document.",
}
def test_indexing_with_no_docs(
record_manager: SQLRecordManager, vector_store: VectorStore
) -> None:
"""Check edge case when loader returns no new docs."""
loader = ToyLoader(documents=[])
assert index(loader, record_manager, vector_store, cleanup="full") == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_aindexing_with_no_docs(
arecord_manager: SQLRecordManager, vector_store: VectorStore
) -> None:
"""Check edge case when loader returns no new docs."""
loader = ToyLoader(documents=[])
assert await aindex(
await loader.alazy_load(), arecord_manager, vector_store, cleanup="full"
) == {
"num_added": 0,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
def test_deduplication(
record_manager: SQLRecordManager, vector_store: VectorStore
) -> None:
"""Check edge case when loader returns no new docs."""
docs = [
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
]
# Should result in only a single document being added
assert index(docs, record_manager, vector_store, cleanup="full") == {
"num_added": 1,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_adeduplication(
arecord_manager: SQLRecordManager, vector_store: VectorStore
) -> None:
"""Check edge case when loader returns no new docs."""
docs = [
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
Document(
page_content="This is a test document.",
metadata={"source": "1"},
),
]
# Should result in only a single document being added
assert await aindex(docs, arecord_manager, vector_store, cleanup="full") == {
"num_added": 1,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
def test_cleanup_with_different_batchsize(
record_manager: SQLRecordManager, vector_store: VectorStore
) -> None:
"""Check that we can clean up with different batch size."""
docs = [
Document(
page_content="This is a test document.",
metadata={"source": str(d)},
)
for d in range(1000)
]
assert index(docs, record_manager, vector_store, cleanup="full") == {
"num_added": 1000,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
docs = [
Document(
page_content="Different doc",
metadata={"source": str(d)},
)
for d in range(1001)
]
assert index(
docs, record_manager, vector_store, cleanup="full", cleanup_batch_size=17
) == {
"num_added": 1001,
"num_deleted": 1000,
"num_skipped": 0,
"num_updated": 0,
}
@pytest.mark.asyncio
@pytest.mark.requires("aiosqlite")
async def test_async_cleanup_with_different_batchsize(
arecord_manager: SQLRecordManager, vector_store: InMemoryVectorStore
) -> None:
"""Check that we can clean up with different batch size."""
docs = [
Document(
page_content="This is a test document.",
metadata={"source": str(d)},
)
for d in range(1000)
]
assert await aindex(docs, arecord_manager, vector_store, cleanup="full") == {
"num_added": 1000,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
docs = [
Document(
page_content="Different doc",
metadata={"source": str(d)},
)
for d in range(1001)
]
assert await aindex(
docs, arecord_manager, vector_store, cleanup="full", cleanup_batch_size=17
) == {
"num_added": 1001,
"num_deleted": 1000,
"num_skipped": 0,
"num_updated": 0,
}
def test_deduplication_v2(
record_manager: SQLRecordManager, vector_store: VectorStore
) -> None:
"""Check edge case when loader returns no new docs."""
docs = [
Document(
page_content="1",
metadata={"source": "1"},
),
Document(
page_content="1",
metadata={"source": "1"},
),
Document(
page_content="2",
metadata={"source": "2"},
),
Document(
page_content="3",
metadata={"source": "3"},
),
]
assert index(docs, record_manager, vector_store, cleanup="full") == {
"num_added": 3,
"num_deleted": 0,
"num_skipped": 0,
"num_updated": 0,
}
# using in memory implementation here
assert isinstance(vector_store, InMemoryVectorStore)
contents = sorted(
[document.page_content for document in vector_store.store.values()]
)
assert contents == ["1", "2", "3"]
async def _to_async_iter(it: Iterable[Any]) -> AsyncIterator[Any]:
"""Convert an iterable to an async iterator."""
for i in it:
yield i
@pytest.mark.asyncio
async def test_abatch() -> None:
"""Test the abatch function."""
batches = _abatch(5, _to_async_iter(range(12)))
assert isinstance(batches, AsyncIterator)
assert [batch async for batch in batches] == [
[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9],
[10, 11],
]
batches = _abatch(1, _to_async_iter(range(3)))
assert isinstance(batches, AsyncIterator)
assert [batch async for batch in batches] == [[0], [1], [2]]
batches = _abatch(2, _to_async_iter(range(5)))
assert isinstance(batches, AsyncIterator)
assert [batch async for batch in batches] == [[0, 1], [2, 3], [4]]
def test_compatible_vectorstore_documentation() -> None:
"""Test which vectorstores are compatible with the indexing API.
This serves as a reminder to update the documentation in [1]
that specifies which vectorstores are compatible with the
indexing API.
Ideally if a developer adds a new vectorstore or modifies
an existing one in such a way that affects its compatibility
with the Indexing API, he/she will see this failed test
case and 1) update docs in [1] and 2) update the `documented`
dict in this test case.
[1] langchain/docs/docs_skeleton/docs/modules/data_connection/indexing.ipynb
"""
# Check if a vectorstore is compatible with the indexing API
def check_compatibility(vector_store: VectorStore) -> bool:
"""Check if a vectorstore is compatible with the indexing API."""
methods = ["delete", "add_documents"]
for method in methods:
if not hasattr(vector_store, method):
return False
# Checking if the vectorstore has overridden the default delete method
# implementation which just raises a NotImplementedError
if getattr(vector_store, "delete") == VectorStore.delete:
return False
return True
# Check all vector store classes for compatibility
compatible = set()
for class_name in langchain.vectorstores.__all__:
# Get the definition of the class
cls = getattr(langchain.vectorstores, class_name)
# If the class corresponds to a vectorstore, check its compatibility
if issubclass(cls, VectorStore):
is_compatible = check_compatibility(cls)
if is_compatible:
compatible.add(class_name)
# These are mentioned in the indexing.ipynb documentation
documented = {
"AnalyticDB",
"AstraDB",
"AzureCosmosDBVectorSearch",
"AwaDB",
"Bagel",
"Cassandra",
"Chroma",
"DashVector",
"DeepLake",
"Dingo",
"ElasticVectorSearch",
"ElasticsearchStore",
"FAISS",
"MomentoVectorIndex",
"MyScale",
"PGVector",
"Pinecone",
"Qdrant",
"Redis",
"ScaNN",
"SemaDB",
"SupabaseVectorStore",
"TileDB",
"TimescaleVector",
"Vald",
"Vearch",
"VespaStore",
"Weaviate",
"ZepVectorStore",
}
assert compatible == documented
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~tests~unit_tests~runnables~test_openai_functions.py | from typing import Any, List, Optional
from langchain_core.schema import ChatResult
from langchain_core.schema.messages import AIMessage, BaseMessage
from langchain_core.schema.output import ChatGeneration
from pytest_mock import MockerFixture
from syrupy import SnapshotAssertion
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.chat_models.base import BaseChatModel
from langchain.runnables.openai_functions import OpenAIFunctionsRouter
class FakeChatOpenAI(BaseChatModel):
@property
def _llm_type(self) -> str:
return "fake-openai-chat-model"
def _generate(
self,
messages: List[BaseMessage],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> ChatResult:
return ChatResult(
generations=[
ChatGeneration(
message=AIMessage(
content="",
additional_kwargs={
"function_call": {
"name": "accept",
"arguments": '{\n "draft": "turtles"\n}',
}
},
)
)
]
)
def test_openai_functions_router(
snapshot: SnapshotAssertion, mocker: MockerFixture
) -> None:
revise = mocker.Mock(
side_effect=lambda kw: f'Revised draft: no more {kw["notes"]}!'
)
accept = mocker.Mock(side_effect=lambda kw: f'Accepted draft: {kw["draft"]}!')
router = OpenAIFunctionsRouter(
{
"revise": revise,
"accept": accept,
},
functions=[
{
"name": "revise",
"description": "Sends the draft for revision.",
"parameters": {
"type": "object",
"properties": {
"notes": {
"type": "string",
"description": "The editor's notes to guide the revision.",
},
},
},
},
{
"name": "accept",
"description": "Accepts the draft.",
"parameters": {
"type": "object",
"properties": {
"draft": {
"type": "string",
"description": "The draft to accept.",
},
},
},
},
],
)
model = FakeChatOpenAI()
chain = model.bind(functions=router.functions) | router
assert router.functions == snapshot
assert chain.invoke("Something about turtles?") == "Accepted draft: turtles!"
revise.assert_not_called()
accept.assert_called_once_with({"draft": "turtles"})
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~tests~integration_tests~llms~test_chatglm.py | """Test ChatGLM API wrapper."""
from langchain_core.schema import LLMResult
from langchain.llms.chatglm import ChatGLM
def test_chatglm_call() -> None:
"""Test valid call to chatglm."""
llm = ChatGLM()
output = llm("北京和上海这两座城市有什么不同？")
assert isinstance(output, str)
def test_chatglm_generate() -> None:
"""Test valid call to chatglm."""
llm = ChatGLM()
output = llm.generate(["who are you"])
assert isinstance(output, LLMResult)
assert isinstance(output.generations, list)
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~vectorstores~llm_rails.py | """Wrapper around LLMRails vector database."""
from __future__ import annotations
import json
import logging
import os
import uuid
from typing import Any, Iterable, List, Optional, Tuple
import requests
from langchain_core.pydantic_v1 import Field
from langchain_core.schema import Document
from langchain_core.schema.embeddings import Embeddings
from langchain.vectorstores.base import VectorStore, VectorStoreRetriever
class LLMRails(VectorStore):
"""Implementation of Vector Store using LLMRails.
See https://llmrails.com/
Example:
.. code-block:: python
from langchain.vectorstores import LLMRails
vectorstore = LLMRails(
api_key=llm_rails_api_key,
datastore_id=datastore_id
)
"""
def __init__(
self,
datastore_id: Optional[str] = None,
api_key: Optional[str] = None,
):
"""Initialize with LLMRails API."""
self._datastore_id = datastore_id or os.environ.get("LLM_RAILS_DATASTORE_ID")
self._api_key = api_key or os.environ.get("LLM_RAILS_API_KEY")
if self._api_key is None:
logging.warning("Can't find Rails credentials in environment.")
self._session = requests.Session() # to reuse connections
self.datastore_id = datastore_id
self.base_url = "https://api.llmrails.com/v1"
def _get_post_headers(self) -> dict:
"""Returns headers that should be attached to each post request."""
return {"X-API-KEY": self._api_key}
def add_texts(
self,
texts: Iterable[str],
metadatas: Optional[List[dict]] = None,
**kwargs: Any,
) -> List[str]:
"""Run more texts through the embeddings and add to the vectorstore.
Args:
texts: Iterable of strings to add to the vectorstore.
Returns:
List of ids from adding the texts into the vectorstore.
"""
names: List[str] = []
for text in texts:
doc_name = str(uuid.uuid4())
response = self._session.post(
f"{self.base_url}/datastores/{self._datastore_id}/text",
json={"name": doc_name, "text": text},
verify=True,
headers=self._get_post_headers(),
)
if response.status_code != 200:
logging.error(
f"Create request failed for doc_name = {doc_name} with status code "
f"{response.status_code}, reason {response.reason}, text "
f"{response.text}"
)
return names
names.append(doc_name)
return names
def add_files(
self,
files_list: Iterable[str],
metadatas: Optional[List[dict]] = None,
**kwargs: Any,
) -> bool:
"""
LLMRails provides a way to add documents directly via our API where
pre-processing and chunking occurs internally in an optimal way
This method provides a way to use that API in LangChain
Args:
files_list: Iterable of strings, each representing a local file path.
Files could be text, HTML, PDF, markdown, doc/docx, ppt/pptx, etc.
see API docs for full list
Returns:
List of ids associated with each of the files indexed
"""
files = []
for file in files_list:
if not os.path.exists(file):
logging.error(f"File {file} does not exist, skipping")
continue
files.append(("file", (os.path.basename(file), open(file, "rb"))))
response = self._session.post(
f"{self.base_url}/datastores/{self._datastore_id}/file",
files=files,
verify=True,
headers=self._get_post_headers(),
)
if response.status_code != 200:
logging.error(
f"Create request failed for datastore = {self._datastore_id} "
f"with status code {response.status_code}, reason {response.reason}, "
f"text {response.text}"
)
return False
return True
def similarity_search_with_score(
self, query: str, k: int = 5
) -> List[Tuple[Document, float]]:
"""Return LLMRails documents most similar to query, along with scores.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 5 Max 10.
alpha: parameter for hybrid search .
Returns:
List of Documents most similar to the query and score for each.
"""
response = self._session.post(
headers=self._get_post_headers(),
url=f"{self.base_url}/datastores/{self._datastore_id}/search",
data=json.dumps({"k": k, "text": query}),
timeout=10,
)
if response.status_code != 200:
logging.error(
"Query failed %s",
f"(code {response.status_code}, reason {response.reason}, details "
f"{response.text})",
)
return []
results = response.json()["results"]
docs = [
(
Document(
page_content=x["text"],
metadata={
key: value
for key, value in x["metadata"].items()
if key != "score"
},
),
x["metadata"]["score"],
)
for x in results
]
return docs
def similarity_search(
self, query: str, k: int = 4, **kwargs: Any
) -> List[Document]:
"""Return LLMRails documents most similar to query, along with scores.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 5.
Returns:
List of Documents most similar to the query
"""
docs_and_scores = self.similarity_search_with_score(query, k=k)
return [doc for doc, _ in docs_and_scores]
@classmethod
def from_texts(
cls,
texts: List[str],
embedding: Optional[Embeddings] = None,
metadatas: Optional[List[dict]] = None,
**kwargs: Any,
) -> LLMRails:
"""Construct LLMRails wrapper from raw documents.
This is intended to be a quick way to get started.
Example:
.. code-block:: python
from langchain.vectorstores import LLMRails
llm_rails = LLMRails.from_texts(
texts,
datastore_id=datastore_id,
api_key=llm_rails_api_key
)
"""
# Note: LLMRails generates its own embeddings, so we ignore the provided
# embeddings (required by interface)
llm_rails = cls(**kwargs)
llm_rails.add_texts(texts)
return llm_rails
def as_retriever(self, **kwargs: Any) -> LLMRailsRetriever:
return LLMRailsRetriever(vectorstore=self, **kwargs)
class LLMRailsRetriever(VectorStoreRetriever):
"""Retriever for LLMRails."""
vectorstore: LLMRails
search_kwargs: dict = Field(default_factory=lambda: {"k": 5})
"""Search params.
k: Number of Documents to return. Defaults to 5.
alpha: parameter for hybrid search .
"""
def add_texts(self, texts: List[str]) -> None:
"""Add text to the datastore.
Args:
texts (List[str]): The text
"""
self.vectorstore.add_texts(texts)
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~chat_loaders~langsmith.py | from __future__ import annotations
import logging
from typing import TYPE_CHECKING, Dict, Iterable, Iterator, List, Optional, Union, cast
from langchain_core.load import load
from langchain_core.schema.chat import ChatSession
from langchain.chat_loaders.base import BaseChatLoader
if TYPE_CHECKING:
from langsmith.client import Client
from langsmith.schemas import Run
logger = logging.getLogger(__name__)
class LangSmithRunChatLoader(BaseChatLoader):
"""
Load chat sessions from a list of LangSmith "llm" runs.
Attributes:
runs (Iterable[Union[str, Run]]): The list of LLM run IDs or run objects.
client (Client): Instance of LangSmith client for fetching data.
"""
def __init__(
self, runs: Iterable[Union[str, Run]], client: Optional["Client"] = None
):
"""
Initialize a new LangSmithRunChatLoader instance.
:param runs: List of LLM run IDs or run objects.
:param client: An instance of LangSmith client, if not provided,
a new client instance will be created.
"""
from langsmith.client import Client
self.runs = runs
self.client = client or Client()
def _load_single_chat_session(self, llm_run: "Run") -> ChatSession:
"""
Convert an individual LangSmith LLM run to a ChatSession.
:param llm_run: The LLM run object.
:return: A chat session representing the run's data.
"""
chat_session = LangSmithRunChatLoader._get_messages_from_llm_run(llm_run)
functions = LangSmithRunChatLoader._get_functions_from_llm_run(llm_run)
if functions:
chat_session["functions"] = functions
return chat_session
@staticmethod
def _get_messages_from_llm_run(llm_run: "Run") -> ChatSession:
"""
Extract messages from a LangSmith LLM run.
:param llm_run: The LLM run object.
:return: ChatSession with the extracted messages.
"""
if llm_run.run_type != "llm":
raise ValueError(f"Expected run of type llm. Got: {llm_run.run_type}")
if "messages" not in llm_run.inputs:
raise ValueError(f"Run has no 'messages' inputs. Got {llm_run.inputs}")
if not llm_run.outputs:
raise ValueError("Cannot convert pending run")
messages = load(llm_run.inputs)["messages"]
message_chunk = load(llm_run.outputs)["generations"][0]["message"]
return ChatSession(messages=messages + [message_chunk])
@staticmethod
def _get_functions_from_llm_run(llm_run: "Run") -> Optional[List[Dict]]:
"""
Extract functions from a LangSmith LLM run if they exist.
:param llm_run: The LLM run object.
:return: Functions from the run or None.
"""
if llm_run.run_type != "llm":
raise ValueError(f"Expected run of type llm. Got: {llm_run.run_type}")
return (llm_run.extra or {}).get("invocation_params", {}).get("functions")
def lazy_load(self) -> Iterator[ChatSession]:
"""
Lazy load the chat sessions from the iterable of run IDs.
This method fetches the runs and converts them to chat sessions on-the-fly,
yielding one session at a time.
:return: Iterator of chat sessions containing messages.
"""
from langsmith.schemas import Run
for run_obj in self.runs:
try:
if hasattr(run_obj, "id"):
run = run_obj
else:
run = self.client.read_run(run_obj)
session = self._load_single_chat_session(cast(Run, run))
yield session
except ValueError as e:
logger.warning(f"Could not load run {run_obj}: {repr(e)}")
continue
class LangSmithDatasetChatLoader(BaseChatLoader):
"""
Load chat sessions from a LangSmith dataset with the "chat" data type.
Attributes:
dataset_name (str): The name of the LangSmith dataset.
client (Client): Instance of LangSmith client for fetching data.
"""
def __init__(self, *, dataset_name: str, client: Optional["Client"] = None):
"""
Initialize a new LangSmithChatDatasetLoader instance.
:param dataset_name: The name of the LangSmith dataset.
:param client: An instance of LangSmith client; if not provided,
a new client instance will be created.
"""
try:
from langsmith.client import Client
except ImportError as e:
raise ImportError(
"The LangSmith client is required to load LangSmith datasets.\n"
"Please install it with `pip install langsmith`"
) from e
self.dataset_name = dataset_name
self.client = client or Client()
def lazy_load(self) -> Iterator[ChatSession]:
"""
Lazy load the chat sessions from the specified LangSmith dataset.
This method fetches the chat data from the dataset and
converts each data point to chat sessions on-the-fly,
yielding one session at a time.
:return: Iterator of chat sessions containing messages.
"""
from langchain.adapters import openai as oai_adapter # noqa: E402
data = self.client.read_dataset_openai_finetuning(
dataset_name=self.dataset_name
)
for data_point in data:
yield ChatSession(
messages=[
oai_adapter.convert_dict_to_message(m)
for m in data_point.get("messages", [])
],
functions=data_point.get("functions"),
)
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~chains~router~embedding_router.py | from __future__ import annotations
from typing import Any, Dict, List, Optional, Sequence, Tuple, Type
from langchain_core.pydantic_v1 import Extra
from langchain_core.schema.embeddings import Embeddings
from langchain_core.schema.vectorstore import VectorStore
from langchain.callbacks.manager import CallbackManagerForChainRun
from langchain.chains.router.base import RouterChain
from langchain.docstore.document import Document
class EmbeddingRouterChain(RouterChain):
"""Chain that uses embeddings to route between options."""
vectorstore: VectorStore
routing_keys: List[str] = ["query"]
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@property
def input_keys(self) -> List[str]:
"""Will be whatever keys the LLM chain prompt expects.
:meta private:
"""
return self.routing_keys
def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
_input = ", ".join([inputs[k] for k in self.routing_keys])
results = self.vectorstore.similarity_search(_input, k=1)
return {"next_inputs": inputs, "destination": results[0].metadata["name"]}
@classmethod
def from_names_and_descriptions(
cls,
names_and_descriptions: Sequence[Tuple[str, Sequence[str]]],
vectorstore_cls: Type[VectorStore],
embeddings: Embeddings,
**kwargs: Any,
) -> EmbeddingRouterChain:
"""Convenience constructor."""
documents = []
for name, descriptions in names_and_descriptions:
for description in descriptions:
documents.append(
Document(page_content=description, metadata={"name": name})
)
vectorstore = vectorstore_cls.from_documents(documents, embeddings)
return cls(vectorstore=vectorstore, **kwargs)
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~tests~integration_tests~memory~test_firestore.py | import json
from langchain_core.schema.messages import _message_to_dict
from langchain.memory import ConversationBufferMemory
from langchain.memory.chat_message_histories import FirestoreChatMessageHistory
def test_memory_with_message_store() -> None:
"""Test the memory with a message store."""
message_history = FirestoreChatMessageHistory(
collection_name="chat_history",
session_id="my-test-session",
user_id="my-test-user",
)
memory = ConversationBufferMemory(
memory_key="baz", chat_memory=message_history, return_messages=True
)
# add some messages
memory.chat_memory.add_ai_message("This is me, the AI")
memory.chat_memory.add_user_message("This is me, the human")
# get the message history from the memory store
# and check if the messages are there as expected
message_history = FirestoreChatMessageHistory(
collection_name="chat_history",
session_id="my-test-session",
user_id="my-test-user",
)
memory = ConversationBufferMemory(
memory_key="baz", chat_memory=message_history, return_messages=True
)
messages = memory.chat_memory.messages
messages_json = json.dumps([_message_to_dict(msg) for msg in messages])
assert "This is me, the AI" in messages_json
assert "This is me, the human" in messages_json
# remove the record from Firestore, so the next test run won't pick it up
memory.chat_memory.clear()
assert memory.chat_memory.messages == []
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~memory~readonly.py | from typing import Any, Dict, List
from langchain_core.schema import BaseMemory
class ReadOnlySharedMemory(BaseMemory):
"""A memory wrapper that is read-only and cannot be changed."""
memory: BaseMemory
@property
def memory_variables(self) -> List[str]:
"""Return memory variables."""
return self.memory.memory_variables
def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
"""Load memory variables from memory."""
return self.memory.load_memory_variables(inputs)
def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
"""Nothing should be saved or changed"""
pass
def clear(self) -> None:
"""Nothing to clear, got a memory like a vault."""
pass
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~tests~integration_tests~chat_models~test_openai.py | """Test ChatOpenAI wrapper."""
from typing import Any, List, Optional, Union
import pytest
from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.schema import (
ChatGeneration,
ChatResult,
LLMResult,
)
from langchain_core.schema.messages import BaseMessage, HumanMessage, SystemMessage
from langchain_core.schema.output import ChatGenerationChunk, GenerationChunk
from langchain.callbacks.base import AsyncCallbackHandler
from langchain.callbacks.manager import CallbackManager
from langchain.chains.openai_functions import (
create_openai_fn_chain,
)
from langchain.chat_models.openai import ChatOpenAI
from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
from tests.unit_tests.callbacks.fake_callback_handler import FakeCallbackHandler
@pytest.mark.scheduled
def test_chat_openai() -> None:
"""Test ChatOpenAI wrapper."""
chat = ChatOpenAI(
temperature=0.7,
base_url=None,
organization=None,
openai_proxy=None,
timeout=10.0,
max_retries=3,
http_client=None,
n=1,
max_tokens=10,
default_headers=None,
default_query=None,
)
message = HumanMessage(content="Hello")
response = chat([message])
assert isinstance(response, BaseMessage)
assert isinstance(response.content, str)
def test_chat_openai_model() -> None:
"""Test ChatOpenAI wrapper handles model_name."""
chat = ChatOpenAI(model="foo")
assert chat.model_name == "foo"
chat = ChatOpenAI(model_name="bar")
assert chat.model_name == "bar"
def test_chat_openai_system_message() -> None:
"""Test ChatOpenAI wrapper with system message."""
chat = ChatOpenAI(max_tokens=10)
system_message = SystemMessage(content="You are to chat with the user.")
human_message = HumanMessage(content="Hello")
response = chat([system_message, human_message])
assert isinstance(response, BaseMessage)
assert isinstance(response.content, str)
@pytest.mark.scheduled
def test_chat_openai_generate() -> None:
"""Test ChatOpenAI wrapper with generate."""
chat = ChatOpenAI(max_tokens=10, n=2)
message = HumanMessage(content="Hello")
response = chat.generate([[message], [message]])
assert isinstance(response, LLMResult)
assert len(response.generations) == 2
assert response.llm_output
assert "system_fingerprint" in response.llm_output
for generations in response.generations:
assert len(generations) == 2
for generation in generations:
assert isinstance(generation, ChatGeneration)
assert isinstance(generation.text, str)
assert generation.text == generation.message.content
@pytest.mark.scheduled
def test_chat_openai_multiple_completions() -> None:
"""Test ChatOpenAI wrapper with multiple completions."""
chat = ChatOpenAI(max_tokens=10, n=5)
message = HumanMessage(content="Hello")
response = chat._generate([message])
assert isinstance(response, ChatResult)
assert len(response.generations) == 5
for generation in response.generations:
assert isinstance(generation.message, BaseMessage)
assert isinstance(generation.message.content, str)
@pytest.mark.scheduled
def test_chat_openai_streaming() -> None:
"""Test that streaming correctly invokes on_llm_new_token callback."""
callback_handler = FakeCallbackHandler()
callback_manager = CallbackManager([callback_handler])
chat = ChatOpenAI(
max_tokens=10,
streaming=True,
temperature=0,
callback_manager=callback_manager,
verbose=True,
)
message = HumanMessage(content="Hello")
response = chat([message])
assert callback_handler.llm_streams > 0
assert isinstance(response, BaseMessage)
@pytest.mark.scheduled
def test_chat_openai_streaming_generation_info() -> None:
"""Test that generation info is preserved when streaming."""
class _FakeCallback(FakeCallbackHandler):
saved_things: dict = {}
def on_llm_end(
self,
*args: Any,
**kwargs: Any,
) -> Any:
# Save the generation
self.saved_things["generation"] = args[0]
callback = _FakeCallback()
callback_manager = CallbackManager([callback])
chat = ChatOpenAI(
max_tokens=2,
temperature=0,
callback_manager=callback_manager,
)
list(chat.stream("hi"))
generation = callback.saved_things["generation"]
# `Hello!` is two tokens, assert that that is what is returned
assert generation.generations[0][0].text == "Hello!"
def test_chat_openai_llm_output_contains_model_name() -> None:
"""Test llm_output contains model_name."""
chat = ChatOpenAI(max_tokens=10)
message = HumanMessage(content="Hello")
llm_result = chat.generate([[message]])
assert llm_result.llm_output is not None
assert llm_result.llm_output["model_name"] == chat.model_name
def test_chat_openai_streaming_llm_output_contains_model_name() -> None:
"""Test llm_output contains model_name."""
chat = ChatOpenAI(max_tokens=10, streaming=True)
message = HumanMessage(content="Hello")
llm_result = chat.generate([[message]])
assert llm_result.llm_output is not None
assert llm_result.llm_output["model_name"] == chat.model_name
def test_chat_openai_invalid_streaming_params() -> None:
"""Test that streaming correctly invokes on_llm_new_token callback."""
with pytest.raises(ValueError):
ChatOpenAI(
max_tokens=10,
streaming=True,
temperature=0,
n=5,
)
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_async_chat_openai() -> None:
"""Test async generation."""
chat = ChatOpenAI(max_tokens=10, n=2)
message = HumanMessage(content="Hello")
response = await chat.agenerate([[message], [message]])
assert isinstance(response, LLMResult)
assert len(response.generations) == 2
assert response.llm_output
assert "system_fingerprint" in response.llm_output
for generations in response.generations:
assert len(generations) == 2
for generation in generations:
assert isinstance(generation, ChatGeneration)
assert isinstance(generation.text, str)
assert generation.text == generation.message.content
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_async_chat_openai_streaming() -> None:
"""Test that streaming correctly invokes on_llm_new_token callback."""
callback_handler = FakeCallbackHandler()
callback_manager = CallbackManager([callback_handler])
chat = ChatOpenAI(
max_tokens=10,
streaming=True,
temperature=0,
callback_manager=callback_manager,
verbose=True,
)
message = HumanMessage(content="Hello")
response = await chat.agenerate([[message], [message]])
assert callback_handler.llm_streams > 0
assert isinstance(response, LLMResult)
assert len(response.generations) == 2
for generations in response.generations:
assert len(generations) == 1
for generation in generations:
assert isinstance(generation, ChatGeneration)
assert isinstance(generation.text, str)
assert generation.text == generation.message.content
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_async_chat_openai_streaming_with_function() -> None:
"""Test ChatOpenAI wrapper with multiple completions."""
class MyCustomAsyncHandler(AsyncCallbackHandler):
def __init__(self) -> None:
super().__init__()
self._captured_tokens: List[str] = []
self._captured_chunks: List[
Optional[Union[ChatGenerationChunk, GenerationChunk]]
] = []
def on_llm_new_token(
self,
token: str,
*,
chunk: Optional[Union[ChatGenerationChunk, GenerationChunk]] = None,
**kwargs: Any,
) -> Any:
self._captured_tokens.append(token)
self._captured_chunks.append(chunk)
json_schema = {
"title": "Person",
"description": "Identifying information about a person.",
"type": "object",
"properties": {
"name": {
"title": "Name",
"description": "The person's name",
"type": "string",
},
"age": {
"title": "Age",
"description": "The person's age",
"type": "integer",
},
"fav_food": {
"title": "Fav Food",
"description": "The person's favorite food",
"type": "string",
},
},
"required": ["name", "age"],
}
callback_handler = MyCustomAsyncHandler()
callback_manager = CallbackManager([callback_handler])
chat = ChatOpenAI(
max_tokens=10,
n=1,
callback_manager=callback_manager,
streaming=True,
)
prompt_msgs = [
SystemMessage(
content="You are a world class algorithm for "
"extracting information in structured formats."
),
HumanMessage(
content="Use the given format to extract "
"information from the following input:"
),
HumanMessagePromptTemplate.from_template("{input}"),
HumanMessage(content="Tips: Make sure to answer in the correct format"),
]
prompt = ChatPromptTemplate(messages=prompt_msgs)
function: Any = {
"name": "output_formatter",
"description": (
"Output formatter. Should always be used to format your response to the"
" user."
),
"parameters": json_schema,
}
chain = create_openai_fn_chain(
[function],
chat,
prompt,
output_parser=None,
)
message = HumanMessage(content="Sally is 13 years old")
response = await chain.agenerate([{"input": message}])
assert isinstance(response, LLMResult)
assert len(response.generations) == 1
for generations in response.generations:
assert len(generations) == 1
for generation in generations:
assert isinstance(generation, ChatGeneration)
assert isinstance(generation.text, str)
assert generation.text == generation.message.content
assert len(callback_handler._captured_tokens) > 0
assert len(callback_handler._captured_chunks) > 0
assert all([chunk is not None for chunk in callback_handler._captured_chunks])
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_async_chat_openai_bind_functions() -> None:
"""Test ChatOpenAI wrapper with multiple completions."""
class Person(BaseModel):
"""Identifying information about a person."""
name: str = Field(..., title="Name", description="The person's name")
age: int = Field(..., title="Age", description="The person's age")
fav_food: Optional[str] = Field(
default=None, title="Fav Food", description="The person's favorite food"
)
chat = ChatOpenAI(
max_tokens=30,
n=1,
streaming=True,
).bind_functions(functions=[Person], function_call="Person")
prompt = ChatPromptTemplate.from_messages(
[
("system", "Use the provided Person function"),
("user", "{input}"),
]
)
chain = prompt | chat | JsonOutputFunctionsParser(args_only=True)
message = HumanMessage(content="Sally is 13 years old")
response = await chain.abatch([{"input": message}])
assert isinstance(response, list)
assert len(response) == 1
for generation in response:
assert isinstance(generation, dict)
assert "name" in generation
assert "age" in generation
def test_chat_openai_extra_kwargs() -> None:
"""Test extra kwargs to chat openai."""
# Check that foo is saved in extra_kwargs.
llm = ChatOpenAI(foo=3, max_tokens=10)
assert llm.max_tokens == 10
assert llm.model_kwargs == {"foo": 3}
# Test that if extra_kwargs are provided, they are added to it.
llm = ChatOpenAI(foo=3, model_kwargs={"bar": 2})
assert llm.model_kwargs == {"foo": 3, "bar": 2}
# Test that if provided twice it errors
with pytest.raises(ValueError):
ChatOpenAI(foo=3, model_kwargs={"foo": 2})
# Test that if explicit param is specified in kwargs it errors
with pytest.raises(ValueError):
ChatOpenAI(model_kwargs={"temperature": 0.2})
# Test that "model" cannot be specified in kwargs
with pytest.raises(ValueError):
ChatOpenAI(model_kwargs={"model": "text-davinci-003"})
@pytest.mark.scheduled
def test_openai_streaming() -> None:
"""Test streaming tokens from OpenAI."""
llm = ChatOpenAI(max_tokens=10)
for token in llm.stream("I'm Pickle Rick"):
assert isinstance(token.content, str)
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_openai_astream() -> None:
"""Test streaming tokens from OpenAI."""
llm = ChatOpenAI(max_tokens=10)
async for token in llm.astream("I'm Pickle Rick"):
assert isinstance(token.content, str)
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_openai_abatch() -> None:
"""Test streaming tokens from ChatOpenAI."""
llm = ChatOpenAI(max_tokens=10)
result = await llm.abatch(["I'm Pickle Rick", "I'm not Pickle Rick"])
for token in result:
assert isinstance(token.content, str)
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_openai_abatch_tags() -> None:
"""Test batch tokens from ChatOpenAI."""
llm = ChatOpenAI(max_tokens=10)
result = await llm.abatch(
["I'm Pickle Rick", "I'm not Pickle Rick"], config={"tags": ["foo"]}
)
for token in result:
assert isinstance(token.content, str)
@pytest.mark.scheduled
def test_openai_batch() -> None:
"""Test batch tokens from ChatOpenAI."""
llm = ChatOpenAI(max_tokens=10)
result = llm.batch(["I'm Pickle Rick", "I'm not Pickle Rick"])
for token in result:
assert isinstance(token.content, str)
@pytest.mark.scheduled
@pytest.mark.asyncio
async def test_openai_ainvoke() -> None:
"""Test invoke tokens from ChatOpenAI."""
llm = ChatOpenAI(max_tokens=10)
result = await llm.ainvoke("I'm Pickle Rick", config={"tags": ["foo"]})
assert isinstance(result.content, str)
@pytest.mark.scheduled
def test_openai_invoke() -> None:
"""Test invoke tokens from ChatOpenAI."""
llm = ChatOpenAI(max_tokens=10)
result = llm.invoke("I'm Pickle Rick", config=dict(tags=["foo"]))
assert isinstance(result.content, str)
| [
"You are a world class algorithm for ",
"Tips: Make sure to answer in the correct format",
"{input}",
"[('system', 'Use the provided Person function'), ('user', '{input}')]",
"Use the given format to extract ",
"extracting information in structured formats.",
"Use the given format to extract information from the following input:",
"You are a world class algorithm for extracting information in structured formats.",
"You are to chat with the user.",
"Use the provided Person function",
"Sally is 13 years old",
"information from the following input:",
"Hello"
] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~chains~openai_functions~qa_with_structure.py | from typing import Any, List, Optional, Type, Union
from langchain_core.prompts import PromptTemplate
from langchain_core.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.schema import BaseLLMOutputParser
from langchain_core.schema.language_model import BaseLanguageModel
from langchain_core.schema.messages import HumanMessage, SystemMessage
from langchain.chains.llm import LLMChain
from langchain.chains.openai_functions.utils import get_llm_kwargs
from langchain.output_parsers.openai_functions import (
OutputFunctionsParser,
PydanticOutputFunctionsParser,
)
class AnswerWithSources(BaseModel):
"""An answer to the question, with sources."""
answer: str = Field(..., description="Answer to the question that was asked")
sources: List[str] = Field(
..., description="List of sources used to answer the question"
)
def create_qa_with_structure_chain(
llm: BaseLanguageModel,
schema: Union[dict, Type[BaseModel]],
output_parser: str = "base",
prompt: Optional[Union[PromptTemplate, ChatPromptTemplate]] = None,
verbose: bool = False,
) -> LLMChain:
"""Create a question answering chain that returns an answer with sources
based on schema.
Args:
llm: Language model to use for the chain.
schema: Pydantic schema to use for the output.
output_parser: Output parser to use. Should be one of `pydantic` or `base`.
Default to `base`.
prompt: Optional prompt to use for the chain.
Returns:
"""
if output_parser == "pydantic":
if not (isinstance(schema, type) and issubclass(schema, BaseModel)):
raise ValueError(
"Must provide a pydantic class for schema when output_parser is "
"'pydantic'."
)
_output_parser: BaseLLMOutputParser = PydanticOutputFunctionsParser(
pydantic_schema=schema
)
elif output_parser == "base":
_output_parser = OutputFunctionsParser()
else:
raise ValueError(
f"Got unexpected output_parser: {output_parser}. "
f"Should be one of `pydantic` or `base`."
)
if isinstance(schema, type) and issubclass(schema, BaseModel):
schema_dict = schema.schema()
else:
schema_dict = schema
function = {
"name": schema_dict["title"],
"description": schema_dict["description"],
"parameters": schema_dict,
}
llm_kwargs = get_llm_kwargs(function)
messages = [
SystemMessage(
content=(
"You are a world class algorithm to answer "
"questions in a specific format."
)
),
HumanMessage(content="Answer question using the following context"),
HumanMessagePromptTemplate.from_template("{context}"),
HumanMessagePromptTemplate.from_template("Question: {question}"),
HumanMessage(content="Tips: Make sure to answer in the correct format"),
]
prompt = prompt or ChatPromptTemplate(messages=messages)
chain = LLMChain(
llm=llm,
prompt=prompt,
llm_kwargs=llm_kwargs,
output_parser=_output_parser,
verbose=verbose,
)
return chain
def create_qa_with_sources_chain(
llm: BaseLanguageModel, verbose: bool = False, **kwargs: Any
) -> LLMChain:
"""Create a question answering chain that returns an answer with sources.
Args:
llm: Language model to use for the chain.
verbose: Whether to print the details of the chain
**kwargs: Keyword arguments to pass to `create_qa_with_structure_chain`.
Returns:
Chain (LLMChain) that can be used to answer questions with citations.
"""
return create_qa_with_structure_chain(
llm, AnswerWithSources, verbose=verbose, **kwargs
)
| [
"{context}",
"You are a world class algorithm to answer questions in a specific format.",
"Tips: Make sure to answer in the correct format",
"Question: {question}",
"Answer question using the following context"
] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~callbacks~aim_callback.py | from copy import deepcopy
from typing import Any, Dict, List, Optional
from langchain_core.schema import AgentAction, AgentFinish, LLMResult
from langchain.callbacks.base import BaseCallbackHandler
def import_aim() -> Any:
"""Import the aim python package and raise an error if it is not installed."""
try:
import aim
except ImportError:
raise ImportError(
"To use the Aim callback manager you need to have the"
" `aim` python package installed."
"Please install it with `pip install aim`"
)
return aim
class BaseMetadataCallbackHandler:
"""This class handles the metadata and associated function states for callbacks.
Attributes:
step (int): The current step.
starts (int): The number of times the start method has been called.
ends (int): The number of times the end method has been called.
errors (int): The number of times the error method has been called.
text_ctr (int): The number of times the text method has been called.
ignore_llm_ (bool): Whether to ignore llm callbacks.
ignore_chain_ (bool): Whether to ignore chain callbacks.
ignore_agent_ (bool): Whether to ignore agent callbacks.
ignore_retriever_ (bool): Whether to ignore retriever callbacks.
always_verbose_ (bool): Whether to always be verbose.
chain_starts (int): The number of times the chain start method has been called.
chain_ends (int): The number of times the chain end method has been called.
llm_starts (int): The number of times the llm start method has been called.
llm_ends (int): The number of times the llm end method has been called.
llm_streams (int): The number of times the text method has been called.
tool_starts (int): The number of times the tool start method has been called.
tool_ends (int): The number of times the tool end method has been called.
agent_ends (int): The number of times the agent end method has been called.
"""
def __init__(self) -> None:
self.step = 0
self.starts = 0
self.ends = 0
self.errors = 0
self.text_ctr = 0
self.ignore_llm_ = False
self.ignore_chain_ = False
self.ignore_agent_ = False
self.ignore_retriever_ = False
self.always_verbose_ = False
self.chain_starts = 0
self.chain_ends = 0
self.llm_starts = 0
self.llm_ends = 0
self.llm_streams = 0
self.tool_starts = 0
self.tool_ends = 0
self.agent_ends = 0
@property
def always_verbose(self) -> bool:
"""Whether to call verbose callbacks even if verbose is False."""
return self.always_verbose_
@property
def ignore_llm(self) -> bool:
"""Whether to ignore LLM callbacks."""
return self.ignore_llm_
@property
def ignore_chain(self) -> bool:
"""Whether to ignore chain callbacks."""
return self.ignore_chain_
@property
def ignore_agent(self) -> bool:
"""Whether to ignore agent callbacks."""
return self.ignore_agent_
@property
def ignore_retriever(self) -> bool:
"""Whether to ignore retriever callbacks."""
return self.ignore_retriever_
def get_custom_callback_meta(self) -> Dict[str, Any]:
return {
"step": self.step,
"starts": self.starts,
"ends": self.ends,
"errors": self.errors,
"text_ctr": self.text_ctr,
"chain_starts": self.chain_starts,
"chain_ends": self.chain_ends,
"llm_starts": self.llm_starts,
"llm_ends": self.llm_ends,
"llm_streams": self.llm_streams,
"tool_starts": self.tool_starts,
"tool_ends": self.tool_ends,
"agent_ends": self.agent_ends,
}
def reset_callback_meta(self) -> None:
"""Reset the callback metadata."""
self.step = 0
self.starts = 0
self.ends = 0
self.errors = 0
self.text_ctr = 0
self.ignore_llm_ = False
self.ignore_chain_ = False
self.ignore_agent_ = False
self.always_verbose_ = False
self.chain_starts = 0
self.chain_ends = 0
self.llm_starts = 0
self.llm_ends = 0
self.llm_streams = 0
self.tool_starts = 0
self.tool_ends = 0
self.agent_ends = 0
return None
class AimCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
"""Callback Handler that logs to Aim.
Parameters:
repo (:obj:`str`, optional): Aim repository path or Repo object to which
Run object is bound. If skipped, default Repo is used.
experiment_name (:obj:`str`, optional): Sets Run's `experiment` property.
'default' if not specified. Can be used later to query runs/sequences.
system_tracking_interval (:obj:`int`, optional): Sets the tracking interval
in seconds for system usage metrics (CPU, Memory, etc.). Set to `None`
to disable system metrics tracking.
log_system_params (:obj:`bool`, optional): Enable/Disable logging of system
params such as installed packages, git info, environment variables, etc.
This handler will utilize the associated callback method called and formats
the input of each callback function with metadata regarding the state of LLM run
and then logs the response to Aim.
"""
def __init__(
self,
repo: Optional[str] = None,
experiment_name: Optional[str] = None,
system_tracking_interval: Optional[int] = 10,
log_system_params: bool = True,
) -> None:
"""Initialize callback handler."""
super().__init__()
aim = import_aim()
self.repo = repo
self.experiment_name = experiment_name
self.system_tracking_interval = system_tracking_interval
self.log_system_params = log_system_params
self._run = aim.Run(
repo=self.repo,
experiment=self.experiment_name,
system_tracking_interval=self.system_tracking_interval,
log_system_params=self.log_system_params,
)
self._run_hash = self._run.hash
self.action_records: list = []
def setup(self, **kwargs: Any) -> None:
aim = import_aim()
if not self._run:
if self._run_hash:
self._run = aim.Run(
self._run_hash,
repo=self.repo,
system_tracking_interval=self.system_tracking_interval,
)
else:
self._run = aim.Run(
repo=self.repo,
experiment=self.experiment_name,
system_tracking_interval=self.system_tracking_interval,
log_system_params=self.log_system_params,
)
self._run_hash = self._run.hash
if kwargs:
for key, value in kwargs.items():
self._run.set(key, value, strict=False)
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when LLM starts."""
aim = import_aim()
self.step += 1
self.llm_starts += 1
self.starts += 1
resp = {"action": "on_llm_start"}
resp.update(self.get_custom_callback_meta())
prompts_res = deepcopy(prompts)
self._run.track(
[aim.Text(prompt) for prompt in prompts_res],
name="on_llm_start",
context=resp,
)
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when LLM ends running."""
aim = import_aim()
self.step += 1
self.llm_ends += 1
self.ends += 1
resp = {"action": "on_llm_end"}
resp.update(self.get_custom_callback_meta())
response_res = deepcopy(response)
generated = [
aim.Text(generation.text)
for generations in response_res.generations
for generation in generations
]
self._run.track(
generated,
name="on_llm_end",
context=resp,
)
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run when LLM generates a new token."""
self.step += 1
self.llm_streams += 1
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when LLM errors."""
self.step += 1
self.errors += 1
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Run when chain starts running."""
aim = import_aim()
self.step += 1
self.chain_starts += 1
self.starts += 1
resp = {"action": "on_chain_start"}
resp.update(self.get_custom_callback_meta())
inputs_res = deepcopy(inputs)
self._run.track(
aim.Text(inputs_res["input"]), name="on_chain_start", context=resp
)
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Run when chain ends running."""
aim = import_aim()
self.step += 1
self.chain_ends += 1
self.ends += 1
resp = {"action": "on_chain_end"}
resp.update(self.get_custom_callback_meta())
outputs_res = deepcopy(outputs)
self._run.track(
aim.Text(outputs_res["output"]), name="on_chain_end", context=resp
)
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when chain errors."""
self.step += 1
self.errors += 1
def on_tool_start(
self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
) -> None:
"""Run when tool starts running."""
aim = import_aim()
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = {"action": "on_tool_start"}
resp.update(self.get_custom_callback_meta())
self._run.track(aim.Text(input_str), name="on_tool_start", context=resp)
def on_tool_end(self, output: str, **kwargs: Any) -> None:
"""Run when tool ends running."""
aim = import_aim()
self.step += 1
self.tool_ends += 1
self.ends += 1
resp = {"action": "on_tool_end"}
resp.update(self.get_custom_callback_meta())
self._run.track(aim.Text(output), name="on_tool_end", context=resp)
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when tool errors."""
self.step += 1
self.errors += 1
def on_text(self, text: str, **kwargs: Any) -> None:
"""
Run when agent is ending.
"""
self.step += 1
self.text_ctr += 1
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run when agent ends running."""
aim = import_aim()
self.step += 1
self.agent_ends += 1
self.ends += 1
resp = {"action": "on_agent_finish"}
resp.update(self.get_custom_callback_meta())
finish_res = deepcopy(finish)
text = "OUTPUT:\n{}\n\nLOG:\n{}".format(
finish_res.return_values["output"], finish_res.log
)
self._run.track(aim.Text(text), name="on_agent_finish", context=resp)
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
aim = import_aim()
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = {
"action": "on_agent_action",
"tool": action.tool,
}
resp.update(self.get_custom_callback_meta())
action_res = deepcopy(action)
text = "TOOL INPUT:\n{}\n\nLOG:\n{}".format(
action_res.tool_input, action_res.log
)
self._run.track(aim.Text(text), name="on_agent_action", context=resp)
def flush_tracker(
self,
repo: Optional[str] = None,
experiment_name: Optional[str] = None,
system_tracking_interval: Optional[int] = 10,
log_system_params: bool = True,
langchain_asset: Any = None,
reset: bool = True,
finish: bool = False,
) -> None:
"""Flush the tracker and reset the session.
Args:
repo (:obj:`str`, optional): Aim repository path or Repo object to which
Run object is bound. If skipped, default Repo is used.
experiment_name (:obj:`str`, optional): Sets Run's `experiment` property.
'default' if not specified. Can be used later to query runs/sequences.
system_tracking_interval (:obj:`int`, optional): Sets the tracking interval
in seconds for system usage metrics (CPU, Memory, etc.). Set to `None`
to disable system metrics tracking.
log_system_params (:obj:`bool`, optional): Enable/Disable logging of system
params such as installed packages, git info, environment variables, etc.
langchain_asset: The langchain asset to save.
reset: Whether to reset the session.
finish: Whether to finish the run.
Returns:
None
"""
if langchain_asset:
try:
for key, value in langchain_asset.dict().items():
self._run.set(key, value, strict=False)
except Exception:
pass
if finish or reset:
self._run.close()
self.reset_callback_meta()
if reset:
self.__init__( # type: ignore
repo=repo if repo else self.repo,
experiment_name=experiment_name
if experiment_name
else self.experiment_name,
system_tracking_interval=system_tracking_interval
if system_tracking_interval
else self.system_tracking_interval,
log_system_params=log_system_params
if log_system_params
else self.log_system_params,
)
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~storage~upstash_redis.py | from typing import Any, Iterator, List, Optional, Sequence, Tuple, cast
from langchain_core.schema import BaseStore
class UpstashRedisStore(BaseStore[str, str]):
"""BaseStore implementation using Upstash Redis as the underlying store."""
def __init__(
self,
*,
client: Any = None,
url: Optional[str] = None,
token: Optional[str] = None,
ttl: Optional[int] = None,
namespace: Optional[str] = None,
) -> None:
"""Initialize the UpstashRedisStore with HTTP API.
Must provide either an Upstash Redis client or a url.
Args:
client: An Upstash Redis instance
url: UPSTASH_REDIS_REST_URL
token: UPSTASH_REDIS_REST_TOKEN
ttl: time to expire keys in seconds if provided,
if None keys will never expire
namespace: if provided, all keys will be prefixed with this namespace
"""
try:
from upstash_redis import Redis
except ImportError as e:
raise ImportError(
"UpstashRedisStore requires the upstash_redis library to be installed. "
"pip install upstash_redis"
) from e
if client and url:
raise ValueError(
"Either an Upstash Redis client or a url must be provided, not both."
)
if client:
if not isinstance(client, Redis):
raise TypeError(
f"Expected Upstash Redis client, got {type(client).__name__}."
)
_client = client
else:
if not url or not token:
raise ValueError(
"Either an Upstash Redis client or url and token must be provided."
)
_client = Redis(url=url, token=token)
self.client = _client
if not isinstance(ttl, int) and ttl is not None:
raise TypeError(f"Expected int or None, got {type(ttl)} instead.")
self.ttl = ttl
self.namespace = namespace
def _get_prefixed_key(self, key: str) -> str:
"""Get the key with the namespace prefix.
Args:
key (str): The original key.
Returns:
str: The key with the namespace prefix.
"""
delimiter = "/"
if self.namespace:
return f"{self.namespace}{delimiter}{key}"
return key
def mget(self, keys: Sequence[str]) -> List[Optional[str]]:
"""Get the values associated with the given keys."""
keys = [self._get_prefixed_key(key) for key in keys]
return cast(
List[Optional[str]],
self.client.mget(*keys),
)
def mset(self, key_value_pairs: Sequence[Tuple[str, str]]) -> None:
"""Set the given key-value pairs."""
for key, value in key_value_pairs:
self.client.set(self._get_prefixed_key(key), value, ex=self.ttl)
def mdelete(self, keys: Sequence[str]) -> None:
"""Delete the given keys."""
_keys = [self._get_prefixed_key(key) for key in keys]
self.client.delete(*_keys)
def yield_keys(self, *, prefix: Optional[str] = None) -> Iterator[str]:
"""Yield keys in the store."""
if prefix:
pattern = self._get_prefixed_key(prefix)
else:
pattern = self._get_prefixed_key("*")
cursor, keys = self.client.scan(0, match=pattern)
for key in keys:
if self.namespace:
relative_key = key[len(self.namespace) + 1 :]
yield relative_key
else:
yield key
while cursor != 0:
cursor, keys = self.client.scan(cursor, match=pattern)
for key in keys:
if self.namespace:
relative_key = key[len(self.namespace) + 1 :]
yield relative_key
else:
yield key
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~llms~textgen.py | import json
import logging
from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
import requests
from langchain_core.pydantic_v1 import Field
from langchain_core.schema.output import GenerationChunk
from langchain.callbacks.manager import (
AsyncCallbackManagerForLLMRun,
CallbackManagerForLLMRun,
)
from langchain.llms.base import LLM
logger = logging.getLogger(__name__)
class TextGen(LLM):
"""text-generation-webui models.
To use, you should have the text-generation-webui installed, a model loaded,
and --api added as a command-line option.
Suggested installation, use one-click installer for your OS:
https://github.com/oobabooga/text-generation-webui#one-click-installers
Parameters below taken from text-generation-webui api example:
https://github.com/oobabooga/text-generation-webui/blob/main/api-examples/api-example.py
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(model_url="http://localhost:8500")
"""
model_url: str
"""The full URL to the textgen webui including http[s]://host:port """
preset: Optional[str] = None
"""The preset to use in the textgen webui """
max_new_tokens: Optional[int] = 250
"""The maximum number of tokens to generate."""
do_sample: bool = Field(True, alias="do_sample")
"""Do sample"""
temperature: Optional[float] = 1.3
"""Primary factor to control randomness of outputs. 0 = deterministic
(only the most likely token is used). Higher value = more randomness."""
top_p: Optional[float] = 0.1
"""If not set to 1, select tokens with probabilities adding up to less than this
number. Higher value = higher range of possible random results."""
typical_p: Optional[float] = 1
"""If not set to 1, select only tokens that are at least this much more likely to
appear than random tokens, given the prior text."""
epsilon_cutoff: Optional[float] = 0 # In units of 1e-4
"""Epsilon cutoff"""
eta_cutoff: Optional[float] = 0 # In units of 1e-4
"""ETA cutoff"""
repetition_penalty: Optional[float] = 1.18
"""Exponential penalty factor for repeating prior tokens. 1 means no penalty,
higher value = less repetition, lower value = more repetition."""
top_k: Optional[float] = 40
"""Similar to top_p, but select instead only the top_k most likely tokens.
Higher value = higher range of possible random results."""
min_length: Optional[int] = 0
"""Minimum generation length in tokens."""
no_repeat_ngram_size: Optional[int] = 0
"""If not set to 0, specifies the length of token sets that are completely blocked
from repeating at all. Higher values = blocks larger phrases,
lower values = blocks words or letters from repeating.
Only 0 or high values are a good idea in most cases."""
num_beams: Optional[int] = 1
"""Number of beams"""
penalty_alpha: Optional[float] = 0
"""Penalty Alpha"""
length_penalty: Optional[float] = 1
"""Length Penalty"""
early_stopping: bool = Field(False, alias="early_stopping")
"""Early stopping"""
seed: int = Field(-1, alias="seed")
"""Seed (-1 for random)"""
add_bos_token: bool = Field(True, alias="add_bos_token")
"""Add the bos_token to the beginning of prompts.
Disabling this can make the replies more creative."""
truncation_length: Optional[int] = 2048
"""Truncate the prompt up to this length. The leftmost tokens are removed if
the prompt exceeds this length. Most models require this to be at most 2048."""
ban_eos_token: bool = Field(False, alias="ban_eos_token")
"""Ban the eos_token. Forces the model to never end the generation prematurely."""
skip_special_tokens: bool = Field(True, alias="skip_special_tokens")
"""Skip special tokens. Some specific models need this unset."""
stopping_strings: Optional[List[str]] = []
"""A list of strings to stop generation when encountered."""
streaming: bool = False
"""Whether to stream the results, token by token."""
@property
def _default_params(self) -> Dict[str, Any]:
"""Get the default parameters for calling textgen."""
return {
"max_new_tokens": self.max_new_tokens,
"do_sample": self.do_sample,
"temperature": self.temperature,
"top_p": self.top_p,
"typical_p": self.typical_p,
"epsilon_cutoff": self.epsilon_cutoff,
"eta_cutoff": self.eta_cutoff,
"repetition_penalty": self.repetition_penalty,
"top_k": self.top_k,
"min_length": self.min_length,
"no_repeat_ngram_size": self.no_repeat_ngram_size,
"num_beams": self.num_beams,
"penalty_alpha": self.penalty_alpha,
"length_penalty": self.length_penalty,
"early_stopping": self.early_stopping,
"seed": self.seed,
"add_bos_token": self.add_bos_token,
"truncation_length": self.truncation_length,
"ban_eos_token": self.ban_eos_token,
"skip_special_tokens": self.skip_special_tokens,
"stopping_strings": self.stopping_strings,
}
@property
def _identifying_params(self) -> Dict[str, Any]:
"""Get the identifying parameters."""
return {**{"model_url": self.model_url}, **self._default_params}
@property
def _llm_type(self) -> str:
"""Return type of llm."""
return "textgen"
def _get_parameters(self, stop: Optional[List[str]] = None) -> Dict[str, Any]:
"""
Performs sanity check, preparing parameters in format needed by textgen.
Args:
stop (Optional[List[str]]): List of stop sequences for textgen.
Returns:
Dictionary containing the combined parameters.
"""
# Raise error if stop sequences are in both input and default params
# if self.stop and stop is not None:
if self.stopping_strings and stop is not None:
raise ValueError("`stop` found in both the input and default params.")
if self.preset is None:
params = self._default_params
else:
params = {"preset": self.preset}
# then sets it as configured, or default to an empty list:
params["stopping_strings"] = self.stopping_strings or stop or []
return params
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Call the textgen web API and return the output.
Args:
prompt: The prompt to use for generation.
stop: A list of strings to stop generation when encountered.
Returns:
The generated text.
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(model_url="http://localhost:5000")
llm("Write a story about llamas.")
"""
if self.streaming:
combined_text_output = ""
for chunk in self._stream(
prompt=prompt, stop=stop, run_manager=run_manager, **kwargs
):
combined_text_output += chunk.text
result = combined_text_output
else:
url = f"{self.model_url}/api/v1/generate"
params = self._get_parameters(stop)
request = params.copy()
request["prompt"] = prompt
response = requests.post(url, json=request)
if response.status_code == 200:
result = response.json()["results"][0]["text"]
else:
print(f"ERROR: response: {response}")
result = ""
return result
async def _acall(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Call the textgen web API and return the output.
Args:
prompt: The prompt to use for generation.
stop: A list of strings to stop generation when encountered.
Returns:
The generated text.
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(model_url="http://localhost:5000")
llm("Write a story about llamas.")
"""
if self.streaming:
combined_text_output = ""
async for chunk in self._astream(
prompt=prompt, stop=stop, run_manager=run_manager, **kwargs
):
combined_text_output += chunk.text
result = combined_text_output
else:
url = f"{self.model_url}/api/v1/generate"
params = self._get_parameters(stop)
request = params.copy()
request["prompt"] = prompt
response = requests.post(url, json=request)
if response.status_code == 200:
result = response.json()["results"][0]["text"]
else:
print(f"ERROR: response: {response}")
result = ""
return result
def _stream(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> Iterator[GenerationChunk]:
"""Yields results objects as they are generated in real time.
It also calls the callback manager's on_llm_new_token event with
similar parameters to the OpenAI LLM class method of the same name.
Args:
prompt: The prompts to pass into the model.
stop: Optional list of stop words to use when generating.
Returns:
A generator representing the stream of tokens being generated.
Yields:
A dictionary like objects containing a string token and metadata.
See text-generation-webui docs and below for more.
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(
model_url = "ws://localhost:5005"
streaming=True
)
for chunk in llm.stream("Ask 'Hi, how are you?' like a pirate:'",
stop=["'","\n"]):
print(chunk, end='', flush=True)
"""
try:
import websocket
except ImportError:
raise ImportError(
"The `websocket-client` package is required for streaming."
)
params = {**self._get_parameters(stop), **kwargs}
url = f"{self.model_url}/api/v1/stream"
request = params.copy()
request["prompt"] = prompt
websocket_client = websocket.WebSocket()
websocket_client.connect(url)
websocket_client.send(json.dumps(request))
while True:
result = websocket_client.recv()
result = json.loads(result)
if result["event"] == "text_stream":
chunk = GenerationChunk(
text=result["text"],
generation_info=None,
)
yield chunk
elif result["event"] == "stream_end":
websocket_client.close()
return
if run_manager:
run_manager.on_llm_new_token(token=chunk.text)
async def _astream(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> AsyncIterator[GenerationChunk]:
"""Yields results objects as they are generated in real time.
It also calls the callback manager's on_llm_new_token event with
similar parameters to the OpenAI LLM class method of the same name.
Args:
prompt: The prompts to pass into the model.
stop: Optional list of stop words to use when generating.
Returns:
A generator representing the stream of tokens being generated.
Yields:
A dictionary like objects containing a string token and metadata.
See text-generation-webui docs and below for more.
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(
model_url = "ws://localhost:5005"
streaming=True
)
for chunk in llm.stream("Ask 'Hi, how are you?' like a pirate:'",
stop=["'","\n"]):
print(chunk, end='', flush=True)
"""
try:
import websocket
except ImportError:
raise ImportError(
"The `websocket-client` package is required for streaming."
)
params = {**self._get_parameters(stop), **kwargs}
url = f"{self.model_url}/api/v1/stream"
request = params.copy()
request["prompt"] = prompt
websocket_client = websocket.WebSocket()
websocket_client.connect(url)
websocket_client.send(json.dumps(request))
while True:
result = websocket_client.recv()
result = json.loads(result)
if result["event"] == "text_stream":
chunk = GenerationChunk(
text=result["text"],
generation_info=None,
)
yield chunk
elif result["event"] == "stream_end":
websocket_client.close()
return
if run_manager:
await run_manager.on_llm_new_token(token=chunk.text)
| [] |
2024-01-10 | axgpt/langchain | libs~core~langchain_core~runnables~history.py | from __future__ import annotations
import asyncio
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Sequence,
Type,
Union,
)
from langchain_core.load import load
from langchain_core.pydantic_v1 import BaseModel, create_model
from langchain_core.runnables.base import Runnable, RunnableBindingBase, RunnableLambda
from langchain_core.runnables.passthrough import RunnablePassthrough
from langchain_core.runnables.utils import (
ConfigurableFieldSpec,
get_unique_config_specs,
)
from langchain_core.schema.chat_history import BaseChatMessageHistory
if TYPE_CHECKING:
from langchain_core.callbacks.tracers.schemas import Run
from langchain_core.runnables.config import RunnableConfig
from langchain_core.schema.messages import BaseMessage
MessagesOrDictWithMessages = Union[Sequence["BaseMessage"], Dict[str, Any]]
GetSessionHistoryCallable = Callable[..., BaseChatMessageHistory]
class RunnableWithMessageHistory(RunnableBindingBase):
"""A runnable that manages chat message history for another runnable.
Base runnable must have inputs and outputs that can be converted to a list of
BaseMessages.
RunnableWithMessageHistory must always be called with a config that contains session_id, e.g.:
``{"configurable": {"session_id": "<SESSION_ID>"}}``
Example (dict input):
.. code-block:: python
from typing import Optional
from langchain_core.chat_models import ChatAnthropic
from langchain_core.memory.chat_message_histories import RedisChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
prompt = ChatPromptTemplate.from_messages([
("system", "You're an assistant who's good at {ability}"),
MessagesPlaceholder(variable_name="history"),
("human", "{question}"),
])
chain = prompt | ChatAnthropic(model="claude-2")
chain_with_history = RunnableWithMessageHistory(
chain,
RedisChatMessageHistory,
input_messages_key="question",
history_messages_key="history",
)
chain_with_history.invoke(
{"ability": "math", "question": "What does cosine mean?"},
config={"configurable": {"session_id": "foo"}}
)
# -> "Cosine is ..."
chain_with_history.invoke(
{"ability": "math", "question": "What's its inverse"},
config={"configurable": {"session_id": "foo"}}
)
# -> "The inverse of cosine is called arccosine ..."
""" # noqa: E501
get_session_history: GetSessionHistoryCallable
input_messages_key: Optional[str] = None
output_messages_key: Optional[str] = None
history_messages_key: Optional[str] = None
def __init__(
self,
runnable: Runnable[
MessagesOrDictWithMessages,
Union[str, BaseMessage, MessagesOrDictWithMessages],
],
get_session_history: GetSessionHistoryCallable,
*,
input_messages_key: Optional[str] = None,
output_messages_key: Optional[str] = None,
history_messages_key: Optional[str] = None,
**kwargs: Any,
) -> None:
"""Initialize RunnableWithMessageHistory.
Args:
runnable: The base Runnable to be wrapped.
Must take as input one of:
- A sequence of BaseMessages
- A dict with one key for all messages
- A dict with one key for the current input string/message(s) and
a separate key for historical messages. If the input key points
to a string, it will be treated as a HumanMessage in history.
Must return as output one of:
- A string which can be treated as an AIMessage
- A BaseMessage or sequence of BaseMessages
- A dict with a key for a BaseMessage or sequence of BaseMessages
get_session_history: Function that returns a new BaseChatMessageHistory
given a session id. Should take a single
positional argument `session_id` which is a string and a named argument
`user_id` which can be a string or None. e.g.:
```python
def get_session_history(
session_id: str,
*,
user_id: Optional[str]=None
) -> BaseChatMessageHistory:
...
```
input_messages_key: Must be specified if the base runnable accepts a dict
as input.
output_messages_key: Must be specified if the base runnable returns a dict
as output.
history_messages_key: Must be specified if the base runnable accepts a dict
as input and expects a separate key for historical messages.
**kwargs: Arbitrary additional kwargs to pass to parent class
``RunnableBindingBase`` init.
""" # noqa: E501
history_chain: Runnable = RunnableLambda(
self._enter_history, self._aenter_history
).with_config(run_name="load_history")
messages_key = history_messages_key or input_messages_key
if messages_key:
history_chain = RunnablePassthrough.assign(
**{messages_key: history_chain}
).with_config(run_name="insert_history")
bound = (
history_chain | runnable.with_listeners(on_end=self._exit_history)
).with_config(run_name="RunnableWithMessageHistory")
super().__init__(
get_session_history=get_session_history,
input_messages_key=input_messages_key,
output_messages_key=output_messages_key,
bound=bound,
history_messages_key=history_messages_key,
**kwargs,
)
@property
def config_specs(self) -> List[ConfigurableFieldSpec]:
return get_unique_config_specs(
super().config_specs
+ [
ConfigurableFieldSpec(
id="session_id",
annotation=str,
name="Session ID",
description="Unique identifier for a session.",
default="",
),
]
)
def get_input_schema(
self, config: Optional[RunnableConfig] = None
) -> Type[BaseModel]:
super_schema = super().get_input_schema(config)
if super_schema.__custom_root_type__ is not None:
from langchain_core.schema.messages import BaseMessage
fields: Dict = {}
if self.input_messages_key and self.history_messages_key:
fields[self.input_messages_key] = (
Union[str, BaseMessage, Sequence[BaseMessage]],
...,
)
elif self.input_messages_key:
fields[self.input_messages_key] = (Sequence[BaseMessage], ...)
else:
fields["__root__"] = (Sequence[BaseMessage], ...)
if self.history_messages_key:
fields[self.history_messages_key] = (Sequence[BaseMessage], ...)
return create_model( # type: ignore[call-overload]
"RunnableWithChatHistoryInput",
**fields,
)
else:
return super_schema
def _get_input_messages(
self, input_val: Union[str, BaseMessage, Sequence[BaseMessage]]
) -> List[BaseMessage]:
from langchain_core.schema.messages import BaseMessage
if isinstance(input_val, str):
from langchain_core.schema.messages import HumanMessage
return [HumanMessage(content=input_val)]
elif isinstance(input_val, BaseMessage):
return [input_val]
elif isinstance(input_val, (list, tuple)):
return list(input_val)
else:
raise ValueError(
f"Expected str, BaseMessage, List[BaseMessage], or Tuple[BaseMessage]. "
f"Got {input_val}."
)
def _get_output_messages(
self, output_val: Union[str, BaseMessage, Sequence[BaseMessage], dict]
) -> List[BaseMessage]:
from langchain_core.schema.messages import BaseMessage
if isinstance(output_val, dict):
output_val = output_val[self.output_messages_key or "output"]
if isinstance(output_val, str):
from langchain_core.schema.messages import AIMessage
return [AIMessage(content=output_val)]
elif isinstance(output_val, BaseMessage):
return [output_val]
elif isinstance(output_val, (list, tuple)):
return list(output_val)
else:
raise ValueError()
def _enter_history(self, input: Any, config: RunnableConfig) -> List[BaseMessage]:
hist = config["configurable"]["message_history"]
# return only historic messages
if self.history_messages_key:
return hist.messages.copy()
# return all messages
else:
input_val = (
input if not self.input_messages_key else input[self.input_messages_key]
)
return hist.messages.copy() + self._get_input_messages(input_val)
async def _aenter_history(
self, input: Dict[str, Any], config: RunnableConfig
) -> List[BaseMessage]:
return await asyncio.get_running_loop().run_in_executor(
None, self._enter_history, input, config
)
def _exit_history(self, run: Run, config: RunnableConfig) -> None:
hist = config["configurable"]["message_history"]
# Get the input messages
inputs = load(run.inputs)
input_val = inputs[self.input_messages_key or "input"]
input_messages = self._get_input_messages(input_val)
# Get the output messages
output_val = load(run.outputs)
output_messages = self._get_output_messages(output_val)
for m in input_messages + output_messages:
hist.add_message(m)
def _merge_configs(self, *configs: Optional[RunnableConfig]) -> RunnableConfig:
config = super()._merge_configs(*configs)
# extract session_id
if "session_id" not in config.get("configurable", {}):
example_input = {self.input_messages_key: "foo"}
example_config = {"configurable": {"session_id": "123"}}
raise ValueError(
"session_id_id is required."
" Pass it in as part of the config argument to .invoke() or .stream()"
f"\neg. chain.invoke({example_input}, {example_config})"
)
# attach message_history
session_id = config["configurable"]["session_id"]
config["configurable"]["message_history"] = self.get_session_history(session_id)
return config
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~document_transformers~long_context_reorder.py | """Reorder documents"""
from typing import Any, List, Sequence
from langchain_core.pydantic_v1 import BaseModel
from langchain_core.schema import BaseDocumentTransformer, Document
def _litm_reordering(documents: List[Document]) -> List[Document]:
"""Lost in the middle reorder: the less relevant documents will be at the
middle of the list and more relevant elements at beginning / end.
See: https://arxiv.org/abs//2307.03172"""
documents.reverse()
reordered_result = []
for i, value in enumerate(documents):
if i % 2 == 1:
reordered_result.append(value)
else:
reordered_result.insert(0, value)
return reordered_result
class LongContextReorder(BaseDocumentTransformer, BaseModel):
"""Lost in the middle:
Performance degrades when models must access relevant information
in the middle of long contexts.
See: https://arxiv.org/abs//2307.03172"""
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
def transform_documents(
self, documents: Sequence[Document], **kwargs: Any
) -> Sequence[Document]:
"""Reorders documents."""
return _litm_reordering(list(documents))
async def atransform_documents(
self, documents: Sequence[Document], **kwargs: Any
) -> Sequence[Document]:
raise NotImplementedError
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~callbacks~mlflow_callback.py | import os
import random
import string
import tempfile
import traceback
from copy import deepcopy
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
from langchain_core.schema import AgentAction, AgentFinish, LLMResult
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.utils import (
BaseMetadataCallbackHandler,
flatten_dict,
hash_string,
import_pandas,
import_spacy,
import_textstat,
)
from langchain.utils import get_from_dict_or_env
def import_mlflow() -> Any:
"""Import the mlflow python package and raise an error if it is not installed."""
try:
import mlflow
except ImportError:
raise ImportError(
"To use the mlflow callback manager you need to have the `mlflow` python "
"package installed. Please install it with `pip install mlflow>=2.3.0`"
)
return mlflow
def analyze_text(
text: str,
nlp: Any = None,
) -> dict:
"""Analyze text using textstat and spacy.
Parameters:
text (str): The text to analyze.
nlp (spacy.lang): The spacy language model to use for visualization.
Returns:
(dict): A dictionary containing the complexity metrics and visualization
files serialized to HTML string.
"""
resp: Dict[str, Any] = {}
textstat = import_textstat()
spacy = import_spacy()
text_complexity_metrics = {
"flesch_reading_ease": textstat.flesch_reading_ease(text),
"flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
"smog_index": textstat.smog_index(text),
"coleman_liau_index": textstat.coleman_liau_index(text),
"automated_readability_index": textstat.automated_readability_index(text),
"dale_chall_readability_score": textstat.dale_chall_readability_score(text),
"difficult_words": textstat.difficult_words(text),
"linsear_write_formula": textstat.linsear_write_formula(text),
"gunning_fog": textstat.gunning_fog(text),
# "text_standard": textstat.text_standard(text),
"fernandez_huerta": textstat.fernandez_huerta(text),
"szigriszt_pazos": textstat.szigriszt_pazos(text),
"gutierrez_polini": textstat.gutierrez_polini(text),
"crawford": textstat.crawford(text),
"gulpease_index": textstat.gulpease_index(text),
"osman": textstat.osman(text),
}
resp.update({"text_complexity_metrics": text_complexity_metrics})
resp.update(text_complexity_metrics)
if nlp is not None:
doc = nlp(text)
dep_out = spacy.displacy.render( # type: ignore
doc, style="dep", jupyter=False, page=True
)
ent_out = spacy.displacy.render( # type: ignore
doc, style="ent", jupyter=False, page=True
)
text_visualizations = {
"dependency_tree": dep_out,
"entities": ent_out,
}
resp.update(text_visualizations)
return resp
def construct_html_from_prompt_and_generation(prompt: str, generation: str) -> Any:
"""Construct an html element from a prompt and a generation.
Parameters:
prompt (str): The prompt.
generation (str): The generation.
Returns:
(str): The html string."""
formatted_prompt = prompt.replace("\n", "<br>")
formatted_generation = generation.replace("\n", "<br>")
return f"""
<p style="color:black;">{formatted_prompt}:</p>
<blockquote>
<p style="color:green;">
{formatted_generation}
</p>
</blockquote>
"""
class MlflowLogger:
"""Callback Handler that logs metrics and artifacts to mlflow server.
Parameters:
name (str): Name of the run.
experiment (str): Name of the experiment.
tags (dict): Tags to be attached for the run.
tracking_uri (str): MLflow tracking server uri.
This handler implements the helper functions to initialize,
log metrics and artifacts to the mlflow server.
"""
def __init__(self, **kwargs: Any):
self.mlflow = import_mlflow()
if "DATABRICKS_RUNTIME_VERSION" in os.environ:
self.mlflow.set_tracking_uri("databricks")
self.mlf_expid = self.mlflow.tracking.fluent._get_experiment_id()
self.mlf_exp = self.mlflow.get_experiment(self.mlf_expid)
else:
tracking_uri = get_from_dict_or_env(
kwargs, "tracking_uri", "MLFLOW_TRACKING_URI", ""
)
self.mlflow.set_tracking_uri(tracking_uri)
# User can set other env variables described here
# > https://www.mlflow.org/docs/latest/tracking.html#logging-to-a-tracking-server
experiment_name = get_from_dict_or_env(
kwargs, "experiment_name", "MLFLOW_EXPERIMENT_NAME"
)
self.mlf_exp = self.mlflow.get_experiment_by_name(experiment_name)
if self.mlf_exp is not None:
self.mlf_expid = self.mlf_exp.experiment_id
else:
self.mlf_expid = self.mlflow.create_experiment(experiment_name)
self.start_run(kwargs["run_name"], kwargs["run_tags"])
def start_run(self, name: str, tags: Dict[str, str]) -> None:
"""To start a new run, auto generates the random suffix for name"""
if name.endswith("-%"):
rname = "".join(random.choices(string.ascii_uppercase + string.digits, k=7))
name = name.replace("%", rname)
self.run = self.mlflow.MlflowClient().create_run(
self.mlf_expid, run_name=name, tags=tags
)
def finish_run(self) -> None:
"""To finish the run."""
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.end_run()
def metric(self, key: str, value: float) -> None:
"""To log metric to mlflow server."""
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.log_metric(key, value)
def metrics(
self, data: Union[Dict[str, float], Dict[str, int]], step: Optional[int] = 0
) -> None:
"""To log all metrics in the input dict."""
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.log_metrics(data)
def jsonf(self, data: Dict[str, Any], filename: str) -> None:
"""To log the input data as json file artifact."""
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.log_dict(data, f"{filename}.json")
def table(self, name: str, dataframe) -> None: # type: ignore
"""To log the input pandas dataframe as a html table"""
self.html(dataframe.to_html(), f"table_{name}")
def html(self, html: str, filename: str) -> None:
"""To log the input html string as html file artifact."""
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.log_text(html, f"{filename}.html")
def text(self, text: str, filename: str) -> None:
"""To log the input text as text file artifact."""
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.log_text(text, f"{filename}.txt")
def artifact(self, path: str) -> None:
"""To upload the file from given path as artifact."""
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.log_artifact(path)
def langchain_artifact(self, chain: Any) -> None:
with self.mlflow.start_run(
run_id=self.run.info.run_id, experiment_id=self.mlf_expid
):
self.mlflow.langchain.log_model(chain, "langchain-model")
class MlflowCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
"""Callback Handler that logs metrics and artifacts to mlflow server.
Parameters:
name (str): Name of the run.
experiment (str): Name of the experiment.
tags (dict): Tags to be attached for the run.
tracking_uri (str): MLflow tracking server uri.
This handler will utilize the associated callback method called and formats
the input of each callback function with metadata regarding the state of LLM run,
and adds the response to the list of records for both the {method}_records and
action. It then logs the response to mlflow server.
"""
def __init__(
self,
name: Optional[str] = "langchainrun-%",
experiment: Optional[str] = "langchain",
tags: Optional[Dict] = None,
tracking_uri: Optional[str] = None,
) -> None:
"""Initialize callback handler."""
import_pandas()
import_textstat()
import_mlflow()
spacy = import_spacy()
super().__init__()
self.name = name
self.experiment = experiment
self.tags = tags or {}
self.tracking_uri = tracking_uri
self.temp_dir = tempfile.TemporaryDirectory()
self.mlflg = MlflowLogger(
tracking_uri=self.tracking_uri,
experiment_name=self.experiment,
run_name=self.name,
run_tags=self.tags,
)
self.action_records: list = []
self.nlp = spacy.load("en_core_web_sm")
self.metrics = {
"step": 0,
"starts": 0,
"ends": 0,
"errors": 0,
"text_ctr": 0,
"chain_starts": 0,
"chain_ends": 0,
"llm_starts": 0,
"llm_ends": 0,
"llm_streams": 0,
"tool_starts": 0,
"tool_ends": 0,
"agent_ends": 0,
}
self.records: Dict[str, Any] = {
"on_llm_start_records": [],
"on_llm_token_records": [],
"on_llm_end_records": [],
"on_chain_start_records": [],
"on_chain_end_records": [],
"on_tool_start_records": [],
"on_tool_end_records": [],
"on_text_records": [],
"on_agent_finish_records": [],
"on_agent_action_records": [],
"action_records": [],
}
def _reset(self) -> None:
for k, v in self.metrics.items():
self.metrics[k] = 0
for k, v in self.records.items():
self.records[k] = []
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when LLM starts."""
self.metrics["step"] += 1
self.metrics["llm_starts"] += 1
self.metrics["starts"] += 1
llm_starts = self.metrics["llm_starts"]
resp: Dict[str, Any] = {}
resp.update({"action": "on_llm_start"})
resp.update(flatten_dict(serialized))
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
for idx, prompt in enumerate(prompts):
prompt_resp = deepcopy(resp)
prompt_resp["prompt"] = prompt
self.records["on_llm_start_records"].append(prompt_resp)
self.records["action_records"].append(prompt_resp)
self.mlflg.jsonf(prompt_resp, f"llm_start_{llm_starts}_prompt_{idx}")
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run when LLM generates a new token."""
self.metrics["step"] += 1
self.metrics["llm_streams"] += 1
llm_streams = self.metrics["llm_streams"]
resp: Dict[str, Any] = {}
resp.update({"action": "on_llm_new_token", "token": token})
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
self.records["on_llm_token_records"].append(resp)
self.records["action_records"].append(resp)
self.mlflg.jsonf(resp, f"llm_new_tokens_{llm_streams}")
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when LLM ends running."""
self.metrics["step"] += 1
self.metrics["llm_ends"] += 1
self.metrics["ends"] += 1
llm_ends = self.metrics["llm_ends"]
resp: Dict[str, Any] = {}
resp.update({"action": "on_llm_end"})
resp.update(flatten_dict(response.llm_output or {}))
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
for generations in response.generations:
for idx, generation in enumerate(generations):
generation_resp = deepcopy(resp)
generation_resp.update(flatten_dict(generation.dict()))
generation_resp.update(
analyze_text(
generation.text,
nlp=self.nlp,
)
)
complexity_metrics: Dict[str, float] = generation_resp.pop(
"text_complexity_metrics"
) # type: ignore # noqa: E501
self.mlflg.metrics(
complexity_metrics,
step=self.metrics["step"],
)
self.records["on_llm_end_records"].append(generation_resp)
self.records["action_records"].append(generation_resp)
self.mlflg.jsonf(resp, f"llm_end_{llm_ends}_generation_{idx}")
dependency_tree = generation_resp["dependency_tree"]
entities = generation_resp["entities"]
self.mlflg.html(dependency_tree, "dep-" + hash_string(generation.text))
self.mlflg.html(entities, "ent-" + hash_string(generation.text))
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when LLM errors."""
self.metrics["step"] += 1
self.metrics["errors"] += 1
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Run when chain starts running."""
self.metrics["step"] += 1
self.metrics["chain_starts"] += 1
self.metrics["starts"] += 1
chain_starts = self.metrics["chain_starts"]
resp: Dict[str, Any] = {}
resp.update({"action": "on_chain_start"})
resp.update(flatten_dict(serialized))
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
chain_input = ",".join([f"{k}={v}" for k, v in inputs.items()])
input_resp = deepcopy(resp)
input_resp["inputs"] = chain_input
self.records["on_chain_start_records"].append(input_resp)
self.records["action_records"].append(input_resp)
self.mlflg.jsonf(input_resp, f"chain_start_{chain_starts}")
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Run when chain ends running."""
self.metrics["step"] += 1
self.metrics["chain_ends"] += 1
self.metrics["ends"] += 1
chain_ends = self.metrics["chain_ends"]
resp: Dict[str, Any] = {}
chain_output = ",".join([f"{k}={v}" for k, v in outputs.items()])
resp.update({"action": "on_chain_end", "outputs": chain_output})
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
self.records["on_chain_end_records"].append(resp)
self.records["action_records"].append(resp)
self.mlflg.jsonf(resp, f"chain_end_{chain_ends}")
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when chain errors."""
self.metrics["step"] += 1
self.metrics["errors"] += 1
def on_tool_start(
self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
) -> None:
"""Run when tool starts running."""
self.metrics["step"] += 1
self.metrics["tool_starts"] += 1
self.metrics["starts"] += 1
tool_starts = self.metrics["tool_starts"]
resp: Dict[str, Any] = {}
resp.update({"action": "on_tool_start", "input_str": input_str})
resp.update(flatten_dict(serialized))
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
self.records["on_tool_start_records"].append(resp)
self.records["action_records"].append(resp)
self.mlflg.jsonf(resp, f"tool_start_{tool_starts}")
def on_tool_end(self, output: str, **kwargs: Any) -> None:
"""Run when tool ends running."""
self.metrics["step"] += 1
self.metrics["tool_ends"] += 1
self.metrics["ends"] += 1
tool_ends = self.metrics["tool_ends"]
resp: Dict[str, Any] = {}
resp.update({"action": "on_tool_end", "output": output})
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
self.records["on_tool_end_records"].append(resp)
self.records["action_records"].append(resp)
self.mlflg.jsonf(resp, f"tool_end_{tool_ends}")
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when tool errors."""
self.metrics["step"] += 1
self.metrics["errors"] += 1
def on_text(self, text: str, **kwargs: Any) -> None:
"""
Run when agent is ending.
"""
self.metrics["step"] += 1
self.metrics["text_ctr"] += 1
text_ctr = self.metrics["text_ctr"]
resp: Dict[str, Any] = {}
resp.update({"action": "on_text", "text": text})
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
self.records["on_text_records"].append(resp)
self.records["action_records"].append(resp)
self.mlflg.jsonf(resp, f"on_text_{text_ctr}")
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run when agent ends running."""
self.metrics["step"] += 1
self.metrics["agent_ends"] += 1
self.metrics["ends"] += 1
agent_ends = self.metrics["agent_ends"]
resp: Dict[str, Any] = {}
resp.update(
{
"action": "on_agent_finish",
"output": finish.return_values["output"],
"log": finish.log,
}
)
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
self.records["on_agent_finish_records"].append(resp)
self.records["action_records"].append(resp)
self.mlflg.jsonf(resp, f"agent_finish_{agent_ends}")
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
self.metrics["step"] += 1
self.metrics["tool_starts"] += 1
self.metrics["starts"] += 1
tool_starts = self.metrics["tool_starts"]
resp: Dict[str, Any] = {}
resp.update(
{
"action": "on_agent_action",
"tool": action.tool,
"tool_input": action.tool_input,
"log": action.log,
}
)
resp.update(self.metrics)
self.mlflg.metrics(self.metrics, step=self.metrics["step"])
self.records["on_agent_action_records"].append(resp)
self.records["action_records"].append(resp)
self.mlflg.jsonf(resp, f"agent_action_{tool_starts}")
def _create_session_analysis_df(self) -> Any:
"""Create a dataframe with all the information from the session."""
pd = import_pandas()
on_llm_start_records_df = pd.DataFrame(self.records["on_llm_start_records"])
on_llm_end_records_df = pd.DataFrame(self.records["on_llm_end_records"])
llm_input_columns = ["step", "prompt"]
if "name" in on_llm_start_records_df.columns:
llm_input_columns.append("name")
elif "id" in on_llm_start_records_df.columns:
# id is llm class's full import path. For example:
# ["langchain", "llms", "openai", "AzureOpenAI"]
on_llm_start_records_df["name"] = on_llm_start_records_df["id"].apply(
lambda id_: id_[-1]
)
llm_input_columns.append("name")
llm_input_prompts_df = (
on_llm_start_records_df[llm_input_columns]
.dropna(axis=1)
.rename({"step": "prompt_step"}, axis=1)
)
complexity_metrics_columns = []
visualizations_columns = []
complexity_metrics_columns = [
"flesch_reading_ease",
"flesch_kincaid_grade",
"smog_index",
"coleman_liau_index",
"automated_readability_index",
"dale_chall_readability_score",
"difficult_words",
"linsear_write_formula",
"gunning_fog",
# "text_standard",
"fernandez_huerta",
"szigriszt_pazos",
"gutierrez_polini",
"crawford",
"gulpease_index",
"osman",
]
visualizations_columns = ["dependency_tree", "entities"]
llm_outputs_df = (
on_llm_end_records_df[
[
"step",
"text",
"token_usage_total_tokens",
"token_usage_prompt_tokens",
"token_usage_completion_tokens",
]
+ complexity_metrics_columns
+ visualizations_columns
]
.dropna(axis=1)
.rename({"step": "output_step", "text": "output"}, axis=1)
)
session_analysis_df = pd.concat([llm_input_prompts_df, llm_outputs_df], axis=1)
session_analysis_df["chat_html"] = session_analysis_df[
["prompt", "output"]
].apply(
lambda row: construct_html_from_prompt_and_generation(
row["prompt"], row["output"]
),
axis=1,
)
return session_analysis_df
def flush_tracker(self, langchain_asset: Any = None, finish: bool = False) -> None:
pd = import_pandas()
self.mlflg.table("action_records", pd.DataFrame(self.records["action_records"]))
session_analysis_df = self._create_session_analysis_df()
chat_html = session_analysis_df.pop("chat_html")
chat_html = chat_html.replace("\n", "", regex=True)
self.mlflg.table("session_analysis", pd.DataFrame(session_analysis_df))
self.mlflg.html("".join(chat_html.tolist()), "chat_html")
if langchain_asset:
# To avoid circular import error
# mlflow only supports LLMChain asset
if "langchain.chains.llm.LLMChain" in str(type(langchain_asset)):
self.mlflg.langchain_artifact(langchain_asset)
else:
langchain_asset_path = str(Path(self.temp_dir.name, "model.json"))
try:
langchain_asset.save(langchain_asset_path)
self.mlflg.artifact(langchain_asset_path)
except ValueError:
try:
langchain_asset.save_agent(langchain_asset_path)
self.mlflg.artifact(langchain_asset_path)
except AttributeError:
print("Could not save model.")
traceback.print_exc()
pass
except NotImplementedError:
print("Could not save model.")
traceback.print_exc()
pass
except NotImplementedError:
print("Could not save model.")
traceback.print_exc()
pass
if finish:
self.mlflg.finish_run()
self._reset()
| [
"\n",
"prompt_step"
] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~callbacks~clearml_callback.py | from __future__ import annotations
import tempfile
from copy import deepcopy
from pathlib import Path
from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Sequence
from langchain_core.schema import AgentAction, AgentFinish, LLMResult
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.utils import (
BaseMetadataCallbackHandler,
flatten_dict,
hash_string,
import_pandas,
import_spacy,
import_textstat,
load_json,
)
if TYPE_CHECKING:
import pandas as pd
def import_clearml() -> Any:
"""Import the clearml python package and raise an error if it is not installed."""
try:
import clearml # noqa: F401
except ImportError:
raise ImportError(
"To use the clearml callback manager you need to have the `clearml` python "
"package installed. Please install it with `pip install clearml`"
)
return clearml
class ClearMLCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
"""Callback Handler that logs to ClearML.
Parameters:
job_type (str): The type of clearml task such as "inference", "testing" or "qc"
project_name (str): The clearml project name
tags (list): Tags to add to the task
task_name (str): Name of the clearml task
visualize (bool): Whether to visualize the run.
complexity_metrics (bool): Whether to log complexity metrics
stream_logs (bool): Whether to stream callback actions to ClearML
This handler will utilize the associated callback method and formats
the input of each callback function with metadata regarding the state of LLM run,
and adds the response to the list of records for both the {method}_records and
action. It then logs the response to the ClearML console.
"""
def __init__(
self,
task_type: Optional[str] = "inference",
project_name: Optional[str] = "langchain_callback_demo",
tags: Optional[Sequence] = None,
task_name: Optional[str] = None,
visualize: bool = False,
complexity_metrics: bool = False,
stream_logs: bool = False,
) -> None:
"""Initialize callback handler."""
clearml = import_clearml()
spacy = import_spacy()
super().__init__()
self.task_type = task_type
self.project_name = project_name
self.tags = tags
self.task_name = task_name
self.visualize = visualize
self.complexity_metrics = complexity_metrics
self.stream_logs = stream_logs
self.temp_dir = tempfile.TemporaryDirectory()
# Check if ClearML task already exists (e.g. in pipeline)
if clearml.Task.current_task():
self.task = clearml.Task.current_task()
else:
self.task = clearml.Task.init( # type: ignore
task_type=self.task_type,
project_name=self.project_name,
tags=self.tags,
task_name=self.task_name,
output_uri=True,
)
self.logger = self.task.get_logger()
warning = (
"The clearml callback is currently in beta and is subject to change "
"based on updates to `langchain`. Please report any issues to "
"https://github.com/allegroai/clearml/issues with the tag `langchain`."
)
self.logger.report_text(warning, level=30, print_console=True)
self.callback_columns: list = []
self.action_records: list = []
self.complexity_metrics = complexity_metrics
self.visualize = visualize
self.nlp = spacy.load("en_core_web_sm")
def _init_resp(self) -> Dict:
return {k: None for k in self.callback_columns}
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when LLM starts."""
self.step += 1
self.llm_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_llm_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
for prompt in prompts:
prompt_resp = deepcopy(resp)
prompt_resp["prompts"] = prompt
self.on_llm_start_records.append(prompt_resp)
self.action_records.append(prompt_resp)
if self.stream_logs:
self.logger.report_text(prompt_resp)
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run when LLM generates a new token."""
self.step += 1
self.llm_streams += 1
resp = self._init_resp()
resp.update({"action": "on_llm_new_token", "token": token})
resp.update(self.get_custom_callback_meta())
self.on_llm_token_records.append(resp)
self.action_records.append(resp)
if self.stream_logs:
self.logger.report_text(resp)
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when LLM ends running."""
self.step += 1
self.llm_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_llm_end"})
resp.update(flatten_dict(response.llm_output or {}))
resp.update(self.get_custom_callback_meta())
for generations in response.generations:
for generation in generations:
generation_resp = deepcopy(resp)
generation_resp.update(flatten_dict(generation.dict()))
generation_resp.update(self.analyze_text(generation.text))
self.on_llm_end_records.append(generation_resp)
self.action_records.append(generation_resp)
if self.stream_logs:
self.logger.report_text(generation_resp)
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when LLM errors."""
self.step += 1
self.errors += 1
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Run when chain starts running."""
self.step += 1
self.chain_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_chain_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
chain_input = inputs.get("input", inputs.get("human_input"))
if isinstance(chain_input, str):
input_resp = deepcopy(resp)
input_resp["input"] = chain_input
self.on_chain_start_records.append(input_resp)
self.action_records.append(input_resp)
if self.stream_logs:
self.logger.report_text(input_resp)
elif isinstance(chain_input, list):
for inp in chain_input:
input_resp = deepcopy(resp)
input_resp.update(inp)
self.on_chain_start_records.append(input_resp)
self.action_records.append(input_resp)
if self.stream_logs:
self.logger.report_text(input_resp)
else:
raise ValueError("Unexpected data format provided!")
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Run when chain ends running."""
self.step += 1
self.chain_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update(
{
"action": "on_chain_end",
"outputs": outputs.get("output", outputs.get("text")),
}
)
resp.update(self.get_custom_callback_meta())
self.on_chain_end_records.append(resp)
self.action_records.append(resp)
if self.stream_logs:
self.logger.report_text(resp)
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when chain errors."""
self.step += 1
self.errors += 1
def on_tool_start(
self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
) -> None:
"""Run when tool starts running."""
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_tool_start", "input_str": input_str})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
self.on_tool_start_records.append(resp)
self.action_records.append(resp)
if self.stream_logs:
self.logger.report_text(resp)
def on_tool_end(self, output: str, **kwargs: Any) -> None:
"""Run when tool ends running."""
self.step += 1
self.tool_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_tool_end", "output": output})
resp.update(self.get_custom_callback_meta())
self.on_tool_end_records.append(resp)
self.action_records.append(resp)
if self.stream_logs:
self.logger.report_text(resp)
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when tool errors."""
self.step += 1
self.errors += 1
def on_text(self, text: str, **kwargs: Any) -> None:
"""
Run when agent is ending.
"""
self.step += 1
self.text_ctr += 1
resp = self._init_resp()
resp.update({"action": "on_text", "text": text})
resp.update(self.get_custom_callback_meta())
self.on_text_records.append(resp)
self.action_records.append(resp)
if self.stream_logs:
self.logger.report_text(resp)
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run when agent ends running."""
self.step += 1
self.agent_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update(
{
"action": "on_agent_finish",
"output": finish.return_values["output"],
"log": finish.log,
}
)
resp.update(self.get_custom_callback_meta())
self.on_agent_finish_records.append(resp)
self.action_records.append(resp)
if self.stream_logs:
self.logger.report_text(resp)
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update(
{
"action": "on_agent_action",
"tool": action.tool,
"tool_input": action.tool_input,
"log": action.log,
}
)
resp.update(self.get_custom_callback_meta())
self.on_agent_action_records.append(resp)
self.action_records.append(resp)
if self.stream_logs:
self.logger.report_text(resp)
def analyze_text(self, text: str) -> dict:
"""Analyze text using textstat and spacy.
Parameters:
text (str): The text to analyze.
Returns:
(dict): A dictionary containing the complexity metrics.
"""
resp = {}
textstat = import_textstat()
spacy = import_spacy()
if self.complexity_metrics:
text_complexity_metrics = {
"flesch_reading_ease": textstat.flesch_reading_ease(text),
"flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
"smog_index": textstat.smog_index(text),
"coleman_liau_index": textstat.coleman_liau_index(text),
"automated_readability_index": textstat.automated_readability_index(
text
),
"dale_chall_readability_score": textstat.dale_chall_readability_score(
text
),
"difficult_words": textstat.difficult_words(text),
"linsear_write_formula": textstat.linsear_write_formula(text),
"gunning_fog": textstat.gunning_fog(text),
"text_standard": textstat.text_standard(text),
"fernandez_huerta": textstat.fernandez_huerta(text),
"szigriszt_pazos": textstat.szigriszt_pazos(text),
"gutierrez_polini": textstat.gutierrez_polini(text),
"crawford": textstat.crawford(text),
"gulpease_index": textstat.gulpease_index(text),
"osman": textstat.osman(text),
}
resp.update(text_complexity_metrics)
if self.visualize and self.nlp and self.temp_dir.name is not None:
doc = self.nlp(text)
dep_out = spacy.displacy.render( # type: ignore
doc, style="dep", jupyter=False, page=True
)
dep_output_path = Path(
self.temp_dir.name, hash_string(f"dep-{text}") + ".html"
)
dep_output_path.open("w", encoding="utf-8").write(dep_out)
ent_out = spacy.displacy.render( # type: ignore
doc, style="ent", jupyter=False, page=True
)
ent_output_path = Path(
self.temp_dir.name, hash_string(f"ent-{text}") + ".html"
)
ent_output_path.open("w", encoding="utf-8").write(ent_out)
self.logger.report_media(
"Dependencies Plot", text, local_path=dep_output_path
)
self.logger.report_media("Entities Plot", text, local_path=ent_output_path)
return resp
@staticmethod
def _build_llm_df(
base_df: pd.DataFrame, base_df_fields: Sequence, rename_map: Mapping
) -> pd.DataFrame:
base_df_fields = [field for field in base_df_fields if field in base_df]
rename_map = {
map_entry_k: map_entry_v
for map_entry_k, map_entry_v in rename_map.items()
if map_entry_k in base_df_fields
}
llm_df = base_df[base_df_fields].dropna(axis=1)
if rename_map:
llm_df = llm_df.rename(rename_map, axis=1)
return llm_df
def _create_session_analysis_df(self) -> Any:
"""Create a dataframe with all the information from the session."""
pd = import_pandas()
on_llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
llm_input_prompts_df = ClearMLCallbackHandler._build_llm_df(
base_df=on_llm_end_records_df,
base_df_fields=["step", "prompts"]
+ (["name"] if "name" in on_llm_end_records_df else ["id"]),
rename_map={"step": "prompt_step"},
)
complexity_metrics_columns = []
visualizations_columns: List = []
if self.complexity_metrics:
complexity_metrics_columns = [
"flesch_reading_ease",
"flesch_kincaid_grade",
"smog_index",
"coleman_liau_index",
"automated_readability_index",
"dale_chall_readability_score",
"difficult_words",
"linsear_write_formula",
"gunning_fog",
"text_standard",
"fernandez_huerta",
"szigriszt_pazos",
"gutierrez_polini",
"crawford",
"gulpease_index",
"osman",
]
llm_outputs_df = ClearMLCallbackHandler._build_llm_df(
on_llm_end_records_df,
[
"step",
"text",
"token_usage_total_tokens",
"token_usage_prompt_tokens",
"token_usage_completion_tokens",
]
+ complexity_metrics_columns
+ visualizations_columns,
{"step": "output_step", "text": "output"},
)
session_analysis_df = pd.concat([llm_input_prompts_df, llm_outputs_df], axis=1)
return session_analysis_df
def flush_tracker(
self,
name: Optional[str] = None,
langchain_asset: Any = None,
finish: bool = False,
) -> None:
"""Flush the tracker and setup the session.
Everything after this will be a new table.
Args:
name: Name of the performed session so far so it is identifiable
langchain_asset: The langchain asset to save.
finish: Whether to finish the run.
Returns:
None
"""
pd = import_pandas()
clearml = import_clearml()
# Log the action records
self.logger.report_table(
"Action Records", name, table_plot=pd.DataFrame(self.action_records)
)
# Session analysis
session_analysis_df = self._create_session_analysis_df()
self.logger.report_table(
"Session Analysis", name, table_plot=session_analysis_df
)
if self.stream_logs:
self.logger.report_text(
{
"action_records": pd.DataFrame(self.action_records),
"session_analysis": session_analysis_df,
}
)
if langchain_asset:
langchain_asset_path = Path(self.temp_dir.name, "model.json")
try:
langchain_asset.save(langchain_asset_path)
# Create output model and connect it to the task
output_model = clearml.OutputModel(
task=self.task, config_text=load_json(langchain_asset_path)
)
output_model.update_weights(
weights_filename=str(langchain_asset_path),
auto_delete_file=False,
target_filename=name,
)
except ValueError:
langchain_asset.save_agent(langchain_asset_path)
output_model = clearml.OutputModel(
task=self.task, config_text=load_json(langchain_asset_path)
)
output_model.update_weights(
weights_filename=str(langchain_asset_path),
auto_delete_file=False,
target_filename=name,
)
except NotImplementedError as e:
print("Could not save model.")
print(repr(e))
pass
# Cleanup after adding everything to ClearML
self.task.flush(wait_for_uploads=True)
self.temp_dir.cleanup()
self.temp_dir = tempfile.TemporaryDirectory()
self.reset_callback_meta()
if finish:
self.task.close()
| [
"name",
"prompt_step"
] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~callbacks~arize_callback.py | from datetime import datetime
from typing import Any, Dict, List, Optional
from langchain_core.schema import AgentAction, AgentFinish, LLMResult
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.utils import import_pandas
class ArizeCallbackHandler(BaseCallbackHandler):
"""Callback Handler that logs to Arize."""
def __init__(
self,
model_id: Optional[str] = None,
model_version: Optional[str] = None,
SPACE_KEY: Optional[str] = None,
API_KEY: Optional[str] = None,
) -> None:
"""Initialize callback handler."""
super().__init__()
self.model_id = model_id
self.model_version = model_version
self.space_key = SPACE_KEY
self.api_key = API_KEY
self.prompt_records: List[str] = []
self.response_records: List[str] = []
self.prediction_ids: List[str] = []
self.pred_timestamps: List[int] = []
self.response_embeddings: List[float] = []
self.prompt_embeddings: List[float] = []
self.prompt_tokens = 0
self.completion_tokens = 0
self.total_tokens = 0
self.step = 0
from arize.pandas.embeddings import EmbeddingGenerator, UseCases
from arize.pandas.logger import Client
self.generator = EmbeddingGenerator.from_use_case(
use_case=UseCases.NLP.SEQUENCE_CLASSIFICATION,
model_name="distilbert-base-uncased",
tokenizer_max_length=512,
batch_size=256,
)
self.arize_client = Client(space_key=SPACE_KEY, api_key=API_KEY)
if SPACE_KEY == "SPACE_KEY" or API_KEY == "API_KEY":
raise ValueError("❌ CHANGE SPACE AND API KEYS")
else:
print("✅ Arize client setup done! Now you can start using Arize!")
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
for prompt in prompts:
self.prompt_records.append(prompt.replace("\n", ""))
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Do nothing."""
pass
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
pd = import_pandas()
from arize.utils.types import (
EmbeddingColumnNames,
Environments,
ModelTypes,
Schema,
)
# Safe check if 'llm_output' and 'token_usage' exist
if response.llm_output and "token_usage" in response.llm_output:
self.prompt_tokens = response.llm_output["token_usage"].get(
"prompt_tokens", 0
)
self.total_tokens = response.llm_output["token_usage"].get(
"total_tokens", 0
)
self.completion_tokens = response.llm_output["token_usage"].get(
"completion_tokens", 0
)
else:
self.prompt_tokens = (
self.total_tokens
) = self.completion_tokens = 0 # assign default value
for generations in response.generations:
for generation in generations:
prompt = self.prompt_records[self.step]
self.step = self.step + 1
prompt_embedding = pd.Series(
self.generator.generate_embeddings(
text_col=pd.Series(prompt.replace("\n", " "))
).reset_index(drop=True)
)
# Assigning text to response_text instead of response
response_text = generation.text.replace("\n", " ")
response_embedding = pd.Series(
self.generator.generate_embeddings(
text_col=pd.Series(generation.text.replace("\n", " "))
).reset_index(drop=True)
)
pred_timestamp = datetime.now().timestamp()
# Define the columns and data
columns = [
"prediction_ts",
"response",
"prompt",
"response_vector",
"prompt_vector",
"prompt_token",
"completion_token",
"total_token",
]
data = [
[
pred_timestamp,
response_text,
prompt,
response_embedding[0],
prompt_embedding[0],
self.prompt_tokens,
self.total_tokens,
self.completion_tokens,
]
]
# Create the DataFrame
df = pd.DataFrame(data, columns=columns)
# Declare prompt and response columns
prompt_columns = EmbeddingColumnNames(
vector_column_name="prompt_vector", data_column_name="prompt"
)
response_columns = EmbeddingColumnNames(
vector_column_name="response_vector", data_column_name="response"
)
schema = Schema(
timestamp_column_name="prediction_ts",
tag_column_names=[
"prompt_token",
"completion_token",
"total_token",
],
prompt_column_names=prompt_columns,
response_column_names=response_columns,
)
response_from_arize = self.arize_client.log(
dataframe=df,
schema=schema,
model_id=self.model_id,
model_version=self.model_version,
model_type=ModelTypes.GENERATIVE_LLM,
environment=Environments.PRODUCTION,
)
if response_from_arize.status_code == 200:
print("✅ Successfully logged data to Arize!")
else:
print(f'❌ Logging failed "{response_from_arize.text}"')
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Do nothing."""
pass
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
pass
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Do nothing."""
pass
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Do nothing."""
pass
def on_tool_start(
self,
serialized: Dict[str, Any],
input_str: str,
**kwargs: Any,
) -> None:
pass
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Do nothing."""
pass
def on_tool_end(
self,
output: str,
observation_prefix: Optional[str] = None,
llm_prefix: Optional[str] = None,
**kwargs: Any,
) -> None:
pass
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
pass
def on_text(self, text: str, **kwargs: Any) -> None:
pass
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
pass
| [
"prompt_vector",
"\n",
" "
] |
2024-01-10 | axgpt/langchain | libs~langchain~langchain~embeddings~gradient_ai.py | import asyncio
import logging
import os
from concurrent.futures import ThreadPoolExecutor
from typing import Any, Callable, Dict, List, Optional, Tuple
import aiohttp
import numpy as np
import requests
from langchain_core.pydantic_v1 import BaseModel, Extra, root_validator
from langchain_core.schema.embeddings import Embeddings
from langchain.utils import get_from_dict_or_env
__all__ = ["GradientEmbeddings"]
class GradientEmbeddings(BaseModel, Embeddings):
"""Gradient.ai Embedding models.
GradientLLM is a class to interact with Embedding Models on gradient.ai
To use, set the environment variable ``GRADIENT_ACCESS_TOKEN`` with your
API token and ``GRADIENT_WORKSPACE_ID`` for your gradient workspace,
or alternatively provide them as keywords to the constructor of this class.
Example:
.. code-block:: python
from langchain.embeddings import GradientEmbeddings
GradientEmbeddings(
model="bge-large",
gradient_workspace_id="12345614fc0_workspace",
gradient_access_token="gradientai-access_token",
)
"""
model: str
"Underlying gradient.ai model id."
gradient_workspace_id: Optional[str] = None
"Underlying gradient.ai workspace_id."
gradient_access_token: Optional[str] = None
"""gradient.ai API Token, which can be generated by going to
https://auth.gradient.ai/select-workspace
and selecting "Access tokens" under the profile drop-down.
"""
gradient_api_url: str = "https://api.gradient.ai/api"
"""Endpoint URL to use."""
client: Any = None #: :meta private:
"""Gradient client."""
# LLM call kwargs
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
@root_validator(allow_reuse=True)
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that api key and python package exists in environment."""
values["gradient_access_token"] = get_from_dict_or_env(
values, "gradient_access_token", "GRADIENT_ACCESS_TOKEN"
)
values["gradient_workspace_id"] = get_from_dict_or_env(
values, "gradient_workspace_id", "GRADIENT_WORKSPACE_ID"
)
values["gradient_api_url"] = get_from_dict_or_env(
values, "gradient_api_url", "GRADIENT_API_URL"
)
values["client"] = TinyAsyncGradientEmbeddingClient(
access_token=values["gradient_access_token"],
workspace_id=values["gradient_workspace_id"],
host=values["gradient_api_url"],
)
try:
import gradientai # noqa
except ImportError:
logging.warning(
"DeprecationWarning: `GradientEmbeddings` will use "
"`pip install gradientai` in future releases of langchain."
)
except Exception:
pass
return values
def embed_documents(self, texts: List[str]) -> List[List[float]]:
"""Call out to Gradient's embedding endpoint.
Args:
texts: The list of texts to embed.
Returns:
List of embeddings, one for each text.
"""
embeddings = self.client.embed(
model=self.model,
texts=texts,
)
return embeddings
async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
"""Async call out to Gradient's embedding endpoint.
Args:
texts: The list of texts to embed.
Returns:
List of embeddings, one for each text.
"""
embeddings = await self.client.aembed(
model=self.model,
texts=texts,
)
return embeddings
def embed_query(self, text: str) -> List[float]:
"""Call out to Gradient's embedding endpoint.
Args:
text: The text to embed.
Returns:
Embeddings for the text.
"""
return self.embed_documents([text])[0]
async def aembed_query(self, text: str) -> List[float]:
"""Async call out to Gradient's embedding endpoint.
Args:
text: The text to embed.
Returns:
Embeddings for the text.
"""
embeddings = await self.aembed_documents([text])
return embeddings[0]
class TinyAsyncGradientEmbeddingClient: #: :meta private:
"""A helper tool to embed Gradient. Not part of Langchain's or Gradients stable API,
direct use discouraged.
To use, set the environment variable ``GRADIENT_ACCESS_TOKEN`` with your
API token and ``GRADIENT_WORKSPACE_ID`` for your gradient workspace,
or alternatively provide them as keywords to the constructor of this class.
Example:
.. code-block:: python
mini_client = TinyAsyncGradientEmbeddingClient(
workspace_id="12345614fc0_workspace",
access_token="gradientai-access_token",
)
embeds = mini_client.embed(
model="bge-large",
text=["doc1", "doc2"]
)
# or
embeds = await mini_client.aembed(
model="bge-large",
text=["doc1", "doc2"]
)
"""
def __init__(
self,
access_token: Optional[str] = None,
workspace_id: Optional[str] = None,
host: str = "https://api.gradient.ai/api",
aiosession: Optional[aiohttp.ClientSession] = None,
) -> None:
self.access_token = access_token or os.environ.get(
"GRADIENT_ACCESS_TOKEN", None
)
self.workspace_id = workspace_id or os.environ.get(
"GRADIENT_WORKSPACE_ID", None
)
self.host = host
self.aiosession = aiosession
if self.access_token is None or len(self.access_token) < 10:
raise ValueError(
"env variable `GRADIENT_ACCESS_TOKEN` or "
" param `access_token` must be set "
)
if self.workspace_id is None or len(self.workspace_id) < 3:
raise ValueError(
"env variable `GRADIENT_WORKSPACE_ID` or "
" param `workspace_id` must be set"
)
if self.host is None or len(self.host) < 3:
raise ValueError(" param `host` must be set to a valid url")
self._batch_size = 128
@staticmethod
def _permute(
texts: List[str], sorter: Callable = len
) -> Tuple[List[str], Callable]:
"""Sort texts in ascending order, and
delivers a lambda expr, which can sort a same length list
https://github.com/UKPLab/sentence-transformers/blob/
c5f93f70eca933c78695c5bc686ceda59651ae3b/sentence_transformers/SentenceTransformer.py#L156
Args:
texts (List[str]): _description_
sorter (Callable, optional): _description_. Defaults to len.
Returns:
Tuple[List[str], Callable]: _description_
Example:
```
texts = ["one","three","four"]
perm_texts, undo = self._permute(texts)
texts == undo(perm_texts)
```
"""
if len(texts) == 1:
# special case query
return texts, lambda t: t
length_sorted_idx = np.argsort([-sorter(sen) for sen in texts])
texts_sorted = [texts[idx] for idx in length_sorted_idx]
return texts_sorted, lambda unsorted_embeddings: [ # noqa E731
unsorted_embeddings[idx] for idx in np.argsort(length_sorted_idx)
]
def _batch(self, texts: List[str]) -> List[List[str]]:
"""
splits Lists of text parts into batches of size max `self._batch_size`
When encoding vector database,
Args:
texts (List[str]): List of sentences
self._batch_size (int, optional): max batch size of one request.
Returns:
List[List[str]]: Batches of List of sentences
"""
if len(texts) == 1:
# special case query
return [texts]
batches = []
for start_index in range(0, len(texts), self._batch_size):
batches.append(texts[start_index : start_index + self._batch_size])
return batches
@staticmethod
def _unbatch(batch_of_texts: List[List[Any]]) -> List[Any]:
if len(batch_of_texts) == 1 and len(batch_of_texts[0]) == 1:
# special case query
return batch_of_texts[0]
texts = []
for sublist in batch_of_texts:
texts.extend(sublist)
return texts
def _kwargs_post_request(self, model: str, texts: List[str]) -> Dict[str, Any]:
"""Build the kwargs for the Post request, used by sync
Args:
model (str): _description_
texts (List[str]): _description_
Returns:
Dict[str, Collection[str]]: _description_
"""
return dict(
url=f"{self.host}/embeddings/{model}",
headers={
"authorization": f"Bearer {self.access_token}",
"x-gradient-workspace-id": f"{self.workspace_id}",
"accept": "application/json",
"content-type": "application/json",
},
json=dict(
inputs=[{"input": i} for i in texts],
),
)
def _sync_request_embed(
self, model: str, batch_texts: List[str]
) -> List[List[float]]:
response = requests.post(
**self._kwargs_post_request(model=model, texts=batch_texts)
)
if response.status_code != 200:
raise Exception(
f"Gradient returned an unexpected response with status "
f"{response.status_code}: {response.text}"
)
return [e["embedding"] for e in response.json()["embeddings"]]
def embed(self, model: str, texts: List[str]) -> List[List[float]]:
"""call the embedding of model
Args:
model (str): to embedding model
texts (List[str]): List of sentences to embed.
Returns:
List[List[float]]: List of vectors for each sentence
"""
perm_texts, unpermute_func = self._permute(texts)
perm_texts_batched = self._batch(perm_texts)
# Request
map_args = (
self._sync_request_embed,
[model] * len(perm_texts_batched),
perm_texts_batched,
)
if len(perm_texts_batched) == 1:
embeddings_batch_perm = list(map(*map_args))
else:
with ThreadPoolExecutor(32) as p:
embeddings_batch_perm = list(p.map(*map_args))
embeddings_perm = self._unbatch(embeddings_batch_perm)
embeddings = unpermute_func(embeddings_perm)
return embeddings
async def _async_request(
self, session: aiohttp.ClientSession, kwargs: Dict[str, Any]
) -> List[List[float]]:
async with session.post(**kwargs) as response:
if response.status != 200:
raise Exception(
f"Gradient returned an unexpected response with status "
f"{response.status}: {response.text}"
)
embedding = (await response.json())["embeddings"]
return [e["embedding"] for e in embedding]
async def aembed(self, model: str, texts: List[str]) -> List[List[float]]:
"""call the embedding of model, async method
Args:
model (str): to embedding model
texts (List[str]): List of sentences to embed.
Returns:
List[List[float]]: List of vectors for each sentence
"""
perm_texts, unpermute_func = self._permute(texts)
perm_texts_batched = self._batch(perm_texts)
# Request
if self.aiosession is None:
self.aiosession = aiohttp.ClientSession(
trust_env=True, connector=aiohttp.TCPConnector(limit=32)
)
async with self.aiosession as session:
embeddings_batch_perm = await asyncio.gather(
*[
self._async_request(
session=session,
**self._kwargs_post_request(model=model, texts=t),
)
for t in perm_texts_batched
]
)
embeddings_perm = self._unbatch(embeddings_batch_perm)
embeddings = unpermute_func(embeddings_perm)
return embeddings
| [
"application/json"
] |
2024-01-10 | axgpt/langchain | libs~langchain~tests~unit_tests~agents~test_mrkl_output_parser.py | import pytest
from langchain_core.schema import AgentAction, AgentFinish, OutputParserException
from langchain.agents.mrkl.output_parser import (
MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
MRKLOutputParser,
)
mrkl_output_parser = MRKLOutputParser()
def test_valid_action_and_action_input_parse() -> None:
llm_output = """I can use the `foo` tool to achieve the goal.
Action: foo
Action Input: bar"""
agent_action: AgentAction = mrkl_output_parser.parse(llm_output) # type: ignore
assert agent_action.tool == "foo"
assert agent_action.tool_input == "bar"
def test_valid_final_answer_parse() -> None:
llm_output = """Final Answer: The best pizza to eat is margaritta """
agent_finish: AgentFinish = mrkl_output_parser.parse(llm_output) # type: ignore
assert (
agent_finish.return_values.get("output")
== "The best pizza to eat is margaritta"
)
def test_missing_action() -> None:
llm_output = """I can use the `foo` tool to achieve the goal."""
with pytest.raises(OutputParserException) as exception_info:
mrkl_output_parser.parse(llm_output)
assert (
exception_info.value.observation == MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE
)
def test_missing_action_input() -> None:
llm_output = """I can use the `foo` tool to achieve the goal.
Action: foo"""
with pytest.raises(OutputParserException) as exception_info:
mrkl_output_parser.parse(llm_output)
assert (
exception_info.value.observation
== MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE
)
def test_final_answer_before_parsable_action() -> None:
llm_output = """Final Answer: The best pizza to eat is margaritta
Action: foo
Action Input: bar
"""
agent_finish: AgentFinish = mrkl_output_parser.parse(llm_output) # type: ignore
assert (
agent_finish.return_values.get("output")
== "The best pizza to eat is margaritta"
)
def test_final_answer_after_parsable_action() -> None:
llm_output = """
Observation: I can use the `foo` tool to achieve the goal.
Action: foo
Action Input: bar
Final Answer: The best pizza to eat is margaritta
"""
with pytest.raises(OutputParserException) as exception_info:
mrkl_output_parser.parse(llm_output)
assert (
"Parsing LLM output produced both a final answer and a parse-able action"
in exception_info.value.args[0]
)
| [] |
2024-01-10 | axgpt/langchain | libs~langchain~tests~unit_tests~document_loaders~test_generic_loader.py | """Test generic loader."""
import os
import tempfile
from pathlib import Path
from typing import Generator, Iterator
import pytest
from langchain_core.schema import Document
from langchain.document_loaders.base import BaseBlobParser
from langchain.document_loaders.blob_loaders import Blob, FileSystemBlobLoader
from langchain.document_loaders.generic import GenericLoader
@pytest.fixture
def toy_dir() -> Generator[Path, None, None]:
"""Yield a pre-populated directory to test the blob loader."""
with tempfile.TemporaryDirectory() as temp_dir:
# Create test.txt
with open(os.path.join(temp_dir, "test.txt"), "w") as test_txt:
test_txt.write("This is a test.txt file.")
# Create test.html
with open(os.path.join(temp_dir, "test.html"), "w") as test_html:
test_html.write(
"<html><body><h1>This is a test.html file.</h1></body></html>"
)
# Create .hidden_file
with open(os.path.join(temp_dir, ".hidden_file"), "w") as hidden_file:
hidden_file.write("This is a hidden file.")
# Create some_dir/nested_file.txt
some_dir = os.path.join(temp_dir, "some_dir")
os.makedirs(some_dir)
with open(os.path.join(some_dir, "nested_file.txt"), "w") as nested_file:
nested_file.write("This is a nested_file.txt file.")
# Create some_dir/other_dir/more_nested.txt
other_dir = os.path.join(some_dir, "other_dir")
os.makedirs(other_dir)
with open(os.path.join(other_dir, "more_nested.txt"), "w") as nested_file:
nested_file.write("This is a more_nested.txt file.")
yield Path(temp_dir)
class AsIsParser(BaseBlobParser):
"""Parser created for testing purposes."""
def lazy_parse(self, blob: Blob) -> Iterator[Document]:
"""Extract the first character of a blob."""
yield Document(page_content=blob.as_string())
def test__init__(toy_dir: str) -> None:
"""Test initialization from init."""
loader = GenericLoader(
FileSystemBlobLoader(toy_dir, suffixes=[".txt"]),
AsIsParser(),
)
docs = loader.load()
assert len(docs) == 3
# Glob order seems to be deterministic with recursion. If this test becomes flaky,
# we can sort the docs by page content.
assert docs[0].page_content == "This is a test.txt file."
def test_from_filesystem_classmethod(toy_dir: str) -> None:
"""Test generic loader."""
loader = GenericLoader.from_filesystem(
toy_dir, suffixes=[".txt"], parser=AsIsParser()
)
docs = loader.load()
assert len(docs) == 3
# Glob order seems to be deterministic with recursion. If this test becomes flaky,
# we can sort the docs by page content.
assert docs[0].page_content == "This is a test.txt file."
def test_from_filesystem_classmethod_with_glob(toy_dir: str) -> None:
"""Test that glob parameter is taken into account."""
loader = GenericLoader.from_filesystem(toy_dir, glob="*.txt", parser=AsIsParser())
docs = loader.load()
assert len(docs) == 1
# Glob order seems to be deterministic with recursion. If this test becomes flaky,
# we can sort the docs by page content.
assert docs[0].page_content == "This is a test.txt file."
@pytest.mark.requires("tqdm")
def test_from_filesystem_classmethod_show_progress(toy_dir: str) -> None:
"""Test that glob parameter is taken into account."""
loader = GenericLoader.from_filesystem(
toy_dir, glob="*.txt", parser=AsIsParser(), show_progress=True
)
docs = loader.load()
assert len(docs) == 1
# Glob order seems to be deterministic with recursion. If this test becomes flaky,
# we can sort the docs by page content.
assert docs[0].page_content == "This is a test.txt file."
def test_from_filesystem_using_default_parser(toy_dir: str) -> None:
"""Use the default generic parser."""
loader = GenericLoader.from_filesystem(
toy_dir,
suffixes=[".txt"],
)
docs = loader.load()
assert len(docs) == 3
# Glob order seems to be deterministic with recursion. If this test becomes flaky,
# we can sort the docs by page content.
assert docs[0].page_content == "This is a test.txt file."
| [] |
2024-01-10 | chho33/LAMOL | settings.py | import os
import json
import argparse
import logging
import datetime
logger = logging.getLogger(__name__)
import GPUtil
from pytorch_transformers import OpenAIGPTLMHeadModel, OpenAIGPTTokenizer, OpenAIGPTConfig
from pytorch_transformers import GPT2LMHeadModel, GPT2Tokenizer, GPT2Config, CONFIG_NAME
import torch
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
FILL_VAL = -1
LEN_FACTOR = 1.163
MEMORY_FACTOR = {
"finetune": 0.58,
"multitask": 0.58,
"lll": 0.35,
"ewc": 0.30,
"mas": 0.18,
"gem": 0.50,
}
TURING_ARCHS = {'Tesla V100', '2080 Ti'}
MODEL_CLASSES = {
'gpt2': (GPT2LMHeadModel, GPT2Tokenizer, GPT2Config),
'openai-gpt': (OpenAIGPTLMHeadModel, OpenAIGPTTokenizer, OpenAIGPTConfig),
}
SAVE_NAME = 'model-'
FINAL_SAVE_NAME = 'model-finish'
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--adam_epsilon", default=1e-4, type=float)
parser.add_argument("--add_task_tokens", action="store_true")
parser.add_argument("--data_dir", type=str, required=True)
parser.add_argument("--debug", action="store_true")
parser.add_argument("--decay_style", type=str, default="linear")
parser.add_argument("--fp32", action="store_true")
parser.add_argument("--real_sample", action="store_true")
parser.add_argument("--unbound", type=int, default=0)
parser.add_argument("--gen_lm_sample_percentage", type=float, default=0.05)
parser.add_argument("--learning_rate", type=float, default=6.25e-5)
parser.add_argument("--logging_steps", type=int, default=1000)
parser.add_argument("--lm_lambda", type=float, default=0.25)
parser.add_argument("--lr_schedule", type=str, default="warmup_linear")
parser.add_argument("--max_grad_norm", type=int, default=1)
parser.add_argument("--max_n_epochs", type=int, default=9)
parser.add_argument("--min_batch_size", type=int, default=4)
parser.add_argument("--min_n_steps", type=int, default=1500)
parser.add_argument("--model_dir_root", type=str, required=True)
parser.add_argument("--model_name", type=str, default="gpt2", choices=["gpt2", "openai-gpt"])
parser.add_argument("--n_gpus", type=int, default=1)
parser.add_argument("--n_train_epochs", type=int, default=3)
parser.add_argument("--dynamic_epochs", action="store_true")
parser.add_argument("--n_warmup_ratio", type=float, default=0.005)
parser.add_argument("--n_workers", type=int, default=4)
parser.add_argument("--use_sep", action="store_true")
parser.add_argument("--reg_lambda", type=float, default=1.)
parser.add_argument("--seed", type=int, default=42)
parser.add_argument("--seq_train_type", type=str, default="lll", choices=["lll","finetune","multitask","mas","ewc","gem"])
parser.add_argument("--tasks", nargs='+', default=["squad2"])
parser.add_argument("--skip_tasks", nargs='+')
parser.add_argument("--temperature_lm", type=float, default=1.0)
parser.add_argument("--temperature_qa", type=float, default=1.0)
parser.add_argument("--test_batch_size", type=int, default=0)
parser.add_argument("--tokens_weight", type=float, default=5)
parser.add_argument("--top_k_lm", type=int, default=20)
parser.add_argument("--top_k_qa", type=int, default=20)
parser.add_argument("--top_p_lm", type=float, default=0.)
parser.add_argument("--top_p_qa", type=float, default=0.)
parser.add_argument("--train_batch_size", type=int, default=0)
parser.add_argument("--weight_decay", type=float, default=0.01)
parser.add_argument("--qp_margin", type=float, default=0.5)
args = parser.parse_args()
if args.debug:
args.logging_steps = 1
torch.manual_seed(0)
torch.backends.cudnn.deterministric = True
args.model_dir_root = os.path.join(args.model_dir_root, args.model_name,
args.seq_train_type, "{}_{}".format("_".join(args.tasks),
args.gen_lm_sample_percentage) if "lll" in args.seq_train_type else "_".join(args.tasks))
args.device_ids = GPUtil.getAvailable(maxLoad=0.05, maxMemory=0.05, limit=args.n_gpus)
if len(args.device_ids) == 0:
logger.error('No available GPUs!')
raise NotImplementedError("No CPU mode available!")
if len(args.device_ids) < args.n_gpus:
logger.warning('Available number of GPU = {} < n_gpus = {}'.format(len(args.device_ids), args.n_gpus))
args.n_gpus = len(args.device_ids)
logger.warning('Continue training with {} GPUs'.format(args.n_gpus))
torch.cuda.set_device(args.device_ids[0])
gpus = GPUtil.getGPUs()
gpu_names = [gpus[device_id].name for device_id in args.device_ids]
if not all(any(turing_arch in gpu_name for turing_arch in TURING_ARCHS) for gpu_name in gpu_names):
logger.warning('Not all gpus support fp16 training! Will use fp32 instead.')
args.fp32 = True
if args.model_name == "openai-gpt":
args.fp32 = True # openai-gpt currently doesn't support fp16
if not args.fp32:
global MEMORY_FACTOR
MEMORY_FACTOR = dict([k, v*1.4] for k, v in MEMORY_FACTOR.items())
args.memory_sizes = [gpus[device_id].memoryTotal for device_id in args.device_ids]
args.memory_sizes[0] = args.memory_sizes[0] * (1 - 0.04 * (args.n_gpus-1))
for i in range(1, args.n_gpus):
args.memory_sizes[i] = args.memory_sizes[i] * 1.04
if args.train_batch_size <= 0:
args.train_batch_size = [int(memory_size * MEMORY_FACTOR[args.seq_train_type]) for memory_size in args.memory_sizes]
if args.test_batch_size <= 0:
args.test_batch_size = [int(memory_size * MEMORY_FACTOR[args.seq_train_type]) for memory_size in args.memory_sizes]
special_tokens = {"ans_token":'__ans__', "pad_token":'__pad__', "unk_token":'__unk__', "eos_token": '<|endoftext|>'}
if args.use_sep:
special_tokens["sep_token"] = '__sep__'
model_class, tokenizer_class, config_class = MODEL_CLASSES[args.model_name]
tokenizer = tokenizer_class.from_pretrained(args.model_name)
tokenizer.add_tokens(list(special_tokens.values()))
special_token_ids = {k:tokenizer.convert_tokens_to_ids(v) for k,v in special_tokens.items()}
model_config = config_class.from_pretrained(args.model_name)
model_config.vocab_size = len(tokenizer)
tokens_weight = torch.ones([model_config.vocab_size], dtype=torch.float).cuda()
tokens_weight[special_token_ids["ans_token"]] = args.tokens_weight
if args.use_sep:
tokens_weight[special_token_ids["sep_token"]] = args.tokens_weight
args.max_len = model_config.n_positions
data_attrs_path = os.path.join(BASE_DIR,"data_attrs.json")
assert os.path.exists(data_attrs_path)
with open(data_attrs_path, "r") as f:
data_attrs = json.load(f)
if args.seq_train_type == "multitask":
args.n_train_epochs = {'_'.join(args.tasks): args.n_train_epochs}
elif args.unbound:
pass
else:
if "gem" in args.seq_train_type:
args.memory_data = []
if args.dynamic_epochs:
data_sizes = {task: data_attrs[task]["train"]["data_size"] for task in args.tasks}
max_total_data_size = max(data_sizes.values()) * args.n_train_epochs
args.n_train_epochs = {d[0]: min(args.max_n_epochs, max_total_data_size//d[1]) for d in data_sizes.items()}
else:
args.n_train_epochs = {task: args.n_train_epochs for task in args.tasks}
return args, model_config, model_class, tokenizer, config_class, special_token_ids, special_tokens, data_attrs, tokens_weight
class TimeFilter(logging.Filter):
def filter(self, record):
try:
last = self.last
except AttributeError:
last = record.relativeCreated
delta = record.relativeCreated/1000 - last/1000
record.relative = "{:.1f}".format(delta)
record.uptime = str(datetime.timedelta(seconds=record.relativeCreated//1000))
self.last = record.relativeCreated
return True
def init_logging(filename):
logging_format = "%(asctime)s - %(uptime)s - %(relative)ss - %(levelname)s - %(name)s - %(message)s"
logging.basicConfig(format=logging_format, filename=filename, filemode='a', level=logging.INFO)
console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter(logging_format))
root_logger = logging.getLogger()
root_logger.addHandler(console_handler)
for handler in root_logger.handlers:
handler.addFilter(TimeFilter())
args, MODEL_CONFIG, MODEL_CLASS, TOKENIZER, CONFIG_CLASS, SPECIAL_TOKEN_IDS, SPECIAL_TOKENS, DATA_ATTRS, TOKENS_WEIGHT = parse_args()
TASK_DICT = {
"squad1": {
"train":os.path.join(args.data_dir,"squad-train-v1.1.json"),
"eval":os.path.join(args.data_dir,"squad-dev-v1.1.json"),
"test":os.path.join(args.data_dir,"squad-dev-v1.1.json"),
"n_train_epochs": args.n_train_epochs
},
"squad2": {
"train":os.path.join(args.data_dir,"squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"squad-dev-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"iwslt.en.de": {
"train":os.path.join(args.data_dir,"iwslt.en.de_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"iwslt.en.de_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"iwslt.en.de_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"cnn_dailymail": {
"train":os.path.join(args.data_dir,"cnn_dailymail_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"cnn_dailymail_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"cnn_dailymail_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"multinli.in.out": {
"train":os.path.join(args.data_dir,"multinli.in.out_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"multinli.in.out_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"multinli.in.out_to_squad-dev-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"sst": {
"train":os.path.join(args.data_dir,"sst_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"sst_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"sst_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"srl": {
"train":os.path.join(args.data_dir,"srl_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"srl_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"srl_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"zre": {
"train":os.path.join(args.data_dir,"zre_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"zre_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"zre_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"woz.en": {
"train":os.path.join(args.data_dir,"woz.en_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"woz.en_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"woz.en_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"wikisql": {
"train":os.path.join(args.data_dir,"wikisql_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"wikisql_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"wikisql_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"schema": {
"train":os.path.join(args.data_dir,"schema_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"schema_to_squad-dev-v2.0.json"),
"test":os.path.join(args.data_dir,"schema_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"ag": {
"train":os.path.join(args.data_dir,"ag_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"ag_to_squad-test-v2.0.json"),
"test":os.path.join(args.data_dir,"ag_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"dbpedia": {
"train":os.path.join(args.data_dir,"dbpedia_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"dbpedia_to_squad-test-v2.0.json"),
"test":os.path.join(args.data_dir,"dbpedia_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"yahoo": {
"train":os.path.join(args.data_dir,"yahoo_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"yahoo_to_squad-test-v2.0.json"),
"test":os.path.join(args.data_dir,"yahoo_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"amazon": {
"train":os.path.join(args.data_dir,"amazon_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"amazon_to_squad-test-v2.0.json"),
"test":os.path.join(args.data_dir,"amazon_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
"yelp": {
"train":os.path.join(args.data_dir,"yelp_to_squad-train-v2.0.json"),
"eval":os.path.join(args.data_dir,"yelp_to_squad-test-v2.0.json"),
"test":os.path.join(args.data_dir,"yelp_to_squad-test-v2.0.json"),
"n_train_epochs": args.n_train_epochs
},
}
| [] |
2024-01-10 | Christianfoley/LLMLyricGen | evaluation~encode_lines.py | import re, unidecode
import openai
import numpy as np
import evaluation.syllable_analysis as sylco
import evaluation.meter_analysis as metco
import eng_to_ipa as ipa
import nltk
WORDS = nltk.corpus.cmudict.dict()
def prep_encoding(text):
"""
Cleans text by removing whitespace, replacing nonstandard characters with
their standard counterparts, etc
Parameters
----------
text : str
any text
Returns
-------
str
cleaned text
"""
text = unidecode.unidecode(text).strip()
if not re.search(r"\S", text):
text = ""
return text
def encode_line_meter_count(line, to_stdout=False):
"""
Encodes a song line (line of text) into a line of digit words representing
the stress of each word in the line.
Ex:
what so proudly we hailed at the twilight's last gleaming
-> 1 1 10 1 1 1 0 12 1 10
Parameters
----------
line : str
string of words (line)
to_stdout : bool, optional
whether to print to stdout, by default False
Returns
-------
str
string of stress encodings (digits)
"""
line = prep_encoding(line)
if line == "":
if to_stdout:
print(line)
return ""
line_stress_list = metco.get_line_meter(line)
out = " ".join(line_stress_list)
if to_stdout:
print(out)
return out
def encode_line_syllable_count(line, to_stdout=False):
"""
Encodes a song line (line of text) into a line of digits representing
the number of syllables per line.
Ex:
the quick brown fox jumps over the lazy dog
-> 1 1 1 1 1 1 1 2 1
Parameters
----------
line : str
string of words (line)
to_stdout : bool, optional
whether to print to stdout, by default False
Returns
-------
string
string of digits, one digit per word
"""
line = prep_encoding(line)
if line == "":
if to_stdout:
print(line)
return line
words = re.findall(r"\b\w+\b", line)
syllable_counts = [sylco.count_syllables(word) for word in words]
out = " ".join(map(str, syllable_counts))
if to_stdout:
if len(syllable_counts) > 0:
out += " " * (30 - len(out))
out += f": {sum(syllable_counts)}"
print(out)
return out
def embed_sbert(text, model):
"""
Uses Senternce bert model to embed text into a low-dimensional
space.
Parameters
----------
text : list, str
text or list of texts to embed
model : torch.nn.module
embedding model
Returns
-------
list, np.ndarray
embedding vector or list of embedding vectors
"""
return model.encode(text)
def embed_ada(text, keyfile="api_key.txt"):
"""
Use openai's ada via the openai API to generate an embedding
Parameters
----------
text : str
text to embed
Returns
-------
np.ndarray
embedding vector
"""
with open(keyfile, "r") as f:
key = f.readline().strip()
openai.api_key = key
embedding = np.array(
openai.Embedding.create(model="text-embedding-ada-002", input=text)
)
return embedding.data[0].embedding
def encode_line_pronunciation(line, to_stdout=False):
"""
Encodes a song line (line of text) into a line of phonemes.
Ex:
the quick brown fox jumps over the lazy dog
-> ðə kwɪk braʊn fɑks ʤəmpt ˈoʊvər ðə ˈleɪzi dɔg
Parameters
----------
line : str
string of words (line)
to_stdout : bool, optional
whether to print to stdout, by default False
Returns
-------
string
string of words in IPA representation
"""
def get_syllables(word):
syllable = ""
syllables = []
for i in range(len(word)):
phoneme = word[i]
if i == 0 and phoneme[-1].isdigit():
syllables.append(phoneme)
elif phoneme[-1].isdigit(): # vowel = end of syllable
syllable += phoneme
syllables.append(syllable)
syllable = ""
else:
syllable += phoneme
if syllable != "":
syllables.append(syllable)
return syllables
if line == "":
if to_stdout:
print(line)
return ""
line = re.sub(r"[^\w\s']", "", line, flags=re.UNICODE)
line = line.replace(",", "").replace(".", "").replace("!", "").strip()
all_syllables = []
for word in line.split(" "):
pronunciation = WORDS.get(word.lower())
if pronunciation is not None:
all_syllables.extend(get_syllables(pronunciation[0]))
return all_syllables
| [] |
2024-01-10 | nirgodin/playlists-creator | server~controllers~content_controllers~existing_playlist_controller.py | from typing import Optional
from genie_common.models.openai import ImageSize
from genie_common.openai import OpenAIClient
from spotipyio import SpotifyClient
from server.consts.app_consts import PLAYLIST_DETAILS, EXISTING_PLAYLIST
from server.consts.data_consts import TRACK
from server.controllers.content_controllers.base_content_controller import BaseContentController
from server.data.playlist_resources import PlaylistResources
from server.logic.data_collection.spotify_playlist_details_collector import PlaylistDetailsCollector
from server.data.playlist_imitation.playlist_details import PlaylistDetails
from server.logic.playlist_imitation.playlist_imitator import PlaylistImitator
from server.logic.playlists_creator import PlaylistsCreator
from server.tools.authenticator import Authenticator
from server.tools.spotify_session_creator import SpotifySessionCreator
from server.utils.spotify_utils import extract_tracks_from_response
class ExistingPlaylistController(BaseContentController):
def __init__(self,
authenticator: Authenticator,
playlists_creator: PlaylistsCreator,
openai_client: OpenAIClient,
session_creator: SpotifySessionCreator,
playlists_imitator: PlaylistImitator,
playlist_details_collector: PlaylistDetailsCollector = PlaylistDetailsCollector()):
super().__init__(authenticator, playlists_creator, openai_client, session_creator)
self._playlist_imitator = playlists_imitator
self._playlist_details_collector = playlist_details_collector
async def _generate_playlist_resources(self,
request_body: dict,
dir_path: str,
spotify_client: SpotifyClient) -> PlaylistResources:
existing_playlist_url = request_body[PLAYLIST_DETAILS][EXISTING_PLAYLIST]
playlist_details = await self._extract_raw_playlist_details(existing_playlist_url, spotify_client)
if playlist_details is None:
return PlaylistResources(None, None)
return await self._playlist_imitator.imitate_playlist(playlist_details, dir_path)
async def _generate_playlist_cover(self, request_body: dict, image_path: str) -> Optional[str]:
return await self._openai_client.images_variation.collect(
image=open(image_path, 'rb'),
n=1,
size=ImageSize.P512
)
async def _extract_raw_playlist_details(self,
playlist_url: str,
spotify_client: SpotifyClient) -> Optional[PlaylistDetails]:
playlist_id = self._extract_playlist_id_from_url(playlist_url)
playlist = await spotify_client.playlists.info.run_single(playlist_id)
items = extract_tracks_from_response(playlist)
tracks = [track.get(TRACK) for track in items]
return await self._playlist_details_collector.collect_playlist(tracks, spotify_client)
@staticmethod
def _extract_playlist_id_from_url(playlist_url: str) -> str:
split_url = playlist_url.split('/')
last_url_component = split_url[-1]
split_url_params = last_url_component.split('?')
return split_url_params[0]
| [] |
2024-01-10 | nirgodin/playlists-creator | server~logic~ocr~tracks_uris_image_extractor.py | from typing import Optional, List, Dict
from spotipyio import SpotifyClient
from server.consts.api_consts import ID
from server.consts.data_consts import URI, TRACKS
from server.consts.prompt_consts import PHOTO_ARTISTS_PROMPT_PREFIX
from server.logic.ocr.artists_collector import ArtistsCollector
from server.logic.ocr.artists_filterer import ArtistsFilterer
from server.logic.ocr.image_text_extractor import ImageTextExtractor
from server.logic.openai.openai_adapter import OpenAIAdapter
from server.utils.general_utils import build_prompt
class TracksURIsImageExtractor:
def __init__(self,
openai_adapter: OpenAIAdapter,
artists_collector: ArtistsCollector,
image_text_extractor: ImageTextExtractor = ImageTextExtractor(),
artists_filterer: ArtistsFilterer = ArtistsFilterer()):
self._openai_adapter = openai_adapter
self._image_text_extractor = image_text_extractor
self._artists_collector = artists_collector
self._artists_filterer = artists_filterer
async def extract_tracks_uris(self, image_path: str, spotify_client: SpotifyClient, language: str = 'eng', country: str = 'US') -> Optional[List[str]]:
artists_names = await self._extract_artists_names(image_path, language)
if not artists_names:
return
artists_details = await self._artists_collector.collect(artists_names, spotify_client)
relevant_artists = self._artists_filterer.filter_relevant_artists(artists_details)
artists_ids = [artist[ID] for artist in relevant_artists]
top_tracks = await spotify_client.artists.top_tracks.run(artists_ids, market=country)
return self._extract_tracks_uris(top_tracks)
async def _extract_artists_names(self, image_path: str, language: str) -> Optional[List[str]]:
image_text = self._image_text_extractor.extract_text(image_path, language)
prompt_suffix = f'```\n{image_text}```'
prompt = build_prompt(PHOTO_ARTISTS_PROMPT_PREFIX, prompt_suffix)
return await self._openai_adapter.chat_completions(prompt, start_char="[", end_char="]", retries_left=1)
@staticmethod
def _extract_tracks_uris(tracks: List[Dict[str, List[dict]]]) -> List[str]:
uris = []
for artist_tracks in tracks:
inner_tracks = artist_tracks.get(TRACKS, [])
if inner_tracks:
for track in inner_tracks:
uris.append(track[URI])
return uris
| [
"```\nPLACEHOLDER```"
] |
2024-01-10 | nirgodin/playlists-creator | server~component_factory.py | import os
from functools import lru_cache
from aiohttp import ClientSession
from async_lru import alru_cache
from genie_common.openai import OpenAIClient
from genie_common.tools import AioPoolExecutor
from genie_common.utils import create_client_session, build_authorization_headers
from genie_datastores.milvus import MilvusClient
from genie_datastores.milvus.operations import get_milvus_uri, get_milvus_token
from genie_datastores.postgres.models import AudioFeatures, SpotifyTrack, TrackLyrics, Artist
from genie_datastores.postgres.operations import get_database_engine
from spotipyio import AccessTokenGenerator
from server.consts.env_consts import USERNAME, PASSWORD, OPENAI_API_KEY, SPOTIPY_CLIENT_ID, SPOTIPY_CLIENT_SECRET, \
SPOTIPY_REDIRECT_URI
from server.controllers.content_controllers.configuration_controller import ConfigurationController
from server.controllers.content_controllers.existing_playlist_controller import ExistingPlaylistController
from server.controllers.content_controllers.for_you_controller import ForYouController
from server.controllers.content_controllers.photo_controller import PhotoController
from server.controllers.content_controllers.prompt_controller import PromptController
from server.controllers.content_controllers.wrapped_controller import WrappedController
from server.controllers.request_body_controller import RequestBodyController
from server.logic.columns_possible_values_querier import ColumnsPossibleValuesQuerier
from server.logic.configuration_photo_prompt.configuration_photo_prompt_creator import ConfigurationPhotoPromptCreator
from server.logic.configuration_photo_prompt.z_score_calculator import ZScoreCalculator
from server.logic.database_client import DatabaseClient
from server.logic.default_filter_params_generator import DefaultFilterParamsGenerator
from server.logic.ocr.artists_collector import ArtistsCollector
from server.logic.ocr.tracks_uris_image_extractor import TracksURIsImageExtractor
from server.logic.openai.columns_descriptions_creator import ColumnsDescriptionsCreator
from server.logic.openai.openai_adapter import OpenAIAdapter
from server.logic.playlist_imitation.playlist_imitator import PlaylistImitator
from server.logic.playlists_creator import PlaylistsCreator
from server.logic.prompt_details_tracks_selector import PromptDetailsTracksSelector
from server.tools.authenticator import Authenticator
from server.tools.spotify_session_creator import SpotifySessionCreator
@alru_cache
async def get_session() -> ClientSession:
session = create_client_session()
return await session.__aenter__()
@alru_cache
async def get_playlists_creator() -> PlaylistsCreator:
session = await get_session()
return PlaylistsCreator(session)
@alru_cache
async def get_openai_client() -> OpenAIClient:
api_key = os.environ[OPENAI_API_KEY]
headers = build_authorization_headers(api_key)
raw_session = create_client_session(headers)
session = await raw_session.__aenter__()
return OpenAIClient.create(session)
@alru_cache
async def get_openai_adapter() -> OpenAIAdapter:
client = await get_openai_client()
return OpenAIAdapter(client)
@alru_cache
async def get_playlist_imitator() -> PlaylistImitator:
session = await get_session()
return PlaylistImitator(session)
async def get_milvus_client() -> MilvusClient:
client = MilvusClient(
uri=get_milvus_uri(),
token=get_milvus_token()
)
return await client.__aenter__()
@alru_cache
async def get_prompt_details_tracks_selector() -> PromptDetailsTracksSelector:
milvus_client = await get_milvus_client()
openai_client = await get_openai_client()
return PromptDetailsTracksSelector(
db_client=get_database_client(),
openai_client=openai_client,
milvus_client=milvus_client
)
@alru_cache
async def get_tracks_uris_image_extractor() -> TracksURIsImageExtractor:
openai_adapter = await get_openai_adapter()
pool_executor = AioPoolExecutor()
return TracksURIsImageExtractor(
openai_adapter=openai_adapter,
artists_collector=ArtistsCollector(pool_executor)
)
def get_possible_values_querier() -> ColumnsPossibleValuesQuerier:
columns = [ # TODO: Think how to add popularity, followers, main_genre, radio_play_count, release_year
AudioFeatures.acousticness,
Artist.gender,
AudioFeatures.danceability,
AudioFeatures.duration_ms, # TODO: Think how to transform to minutes
AudioFeatures.energy,
SpotifyTrack.explicit,
AudioFeatures.instrumentalness,
Artist.is_israeli,
AudioFeatures.key,
TrackLyrics.language,
AudioFeatures.liveness,
AudioFeatures.loudness,
AudioFeatures.mode,
AudioFeatures.tempo,
AudioFeatures.time_signature,
SpotifyTrack.number,
AudioFeatures.valence
]
return ColumnsPossibleValuesQuerier(
db_engine=get_database_engine(),
columns=columns
)
@lru_cache
def get_z_score_calculator() -> ZScoreCalculator:
return ZScoreCalculator(get_database_engine())
async def get_configuration_photo_prompt_creator() -> ConfigurationPhotoPromptCreator:
# TODO: Think how to handle cache here
possible_values_querier = get_possible_values_querier()
columns_values = await possible_values_querier.query()
default_values_generator = DefaultFilterParamsGenerator()
params_default_values = default_values_generator.get_filter_params_defaults(columns_values)
return ConfigurationPhotoPromptCreator(
params_default_values=params_default_values,
z_score_calculator=get_z_score_calculator()
)
def get_columns_descriptions_creator():
return ColumnsDescriptionsCreator(get_possible_values_querier())
async def get_request_body_controller() -> RequestBodyController:
return RequestBodyController(
possible_values_querier=get_possible_values_querier()
)
def get_database_client() -> DatabaseClient:
return DatabaseClient(get_database_engine())
@lru_cache
def get_access_token_generator() -> AccessTokenGenerator:
return AccessTokenGenerator(
client_id=os.environ[SPOTIPY_CLIENT_ID],
client_secret=os.environ[SPOTIPY_CLIENT_SECRET],
redirect_uri=os.environ[SPOTIPY_REDIRECT_URI]
)
@lru_cache
def get_spotify_session_creator() -> SpotifySessionCreator:
return SpotifySessionCreator(get_access_token_generator())
async def get_configuration_controller() -> ConfigurationController:
playlists_creator = await get_playlists_creator()
openai_client = await get_openai_client()
photo_prompt_creator = await get_configuration_photo_prompt_creator()
return ConfigurationController(
authenticator=get_authenticator(),
playlists_creator=playlists_creator,
openai_client=openai_client,
session_creator=get_spotify_session_creator(),
photo_prompt_creator=photo_prompt_creator,
db_client=get_database_client()
)
async def get_prompt_controller() -> PromptController:
playlists_creator = await get_playlists_creator()
openai_client = await get_openai_client()
openai_adapter = await get_openai_adapter()
prompt_details_tracks_selector = await get_prompt_details_tracks_selector()
return PromptController(
authenticator=get_authenticator(),
playlists_creator=playlists_creator,
openai_client=openai_client,
session_creator=get_spotify_session_creator(),
openai_adapter=openai_adapter,
columns_descriptions_creator=get_columns_descriptions_creator(),
prompt_details_tracks_selector=prompt_details_tracks_selector
)
async def get_photo_controller() -> PhotoController:
playlists_creator = await get_playlists_creator()
openai_client = await get_openai_client()
tracks_uris_extractor = await get_tracks_uris_image_extractor()
return PhotoController(
authenticator=get_authenticator(),
playlists_creator=playlists_creator,
openai_client=openai_client,
session_creator=get_spotify_session_creator(),
tracks_uris_extractor=tracks_uris_extractor
)
async def get_existing_playlist_controller() -> ExistingPlaylistController:
playlists_creator = await get_playlists_creator()
openai_client = await get_openai_client()
playlists_imitator = await get_playlist_imitator()
return ExistingPlaylistController(
authenticator=get_authenticator(),
playlists_creator=playlists_creator,
openai_client=openai_client,
session_creator=get_spotify_session_creator(),
playlists_imitator=playlists_imitator
)
async def get_wrapped_controller() -> WrappedController:
playlists_creator = await get_playlists_creator()
openai_client = await get_openai_client()
return WrappedController(
authenticator=get_authenticator(),
playlists_creator=playlists_creator,
openai_client=openai_client,
session_creator=get_spotify_session_creator(),
)
async def get_for_you_controller() -> ForYouController:
playlists_creator = await get_playlists_creator()
openai_client = await get_openai_client()
playlists_imitator = await get_playlist_imitator()
return ForYouController(
authenticator=get_authenticator(),
playlists_creator=playlists_creator,
openai_client=openai_client,
session_creator=get_spotify_session_creator(),
playlists_imitator=playlists_imitator
)
@lru_cache
def get_authenticator() -> Authenticator:
return Authenticator(
username=os.environ[USERNAME],
password=os.environ[PASSWORD]
)
| [] |
2024-01-10 | nirgodin/playlists-creator | server~logic~prompt_details_tracks_selector.py | from typing import List
from genie_common.models.openai import EmbeddingsModel
from genie_common.openai import OpenAIClient
from genie_common.tools import logger
from genie_datastores.milvus import MilvusClient
from genie_datastores.milvus.models import SearchRequest
from genie_datastores.milvus.utils import convert_iterable_to_milvus_filter
from spotipyio.logic.collectors.search_collectors.spotify_search_type import SpotifySearchType
from server.consts.api_consts import ID
from server.data.prompt_details import PromptDetails
from server.logic.database_client import DatabaseClient
from server.utils.spotify_utils import sample_uris, to_uris
class PromptDetailsTracksSelector:
def __init__(self,
db_client: DatabaseClient,
openai_client: OpenAIClient,
milvus_client: MilvusClient):
self._db_client = db_client
self._openai_client = openai_client
self._milvus_client = milvus_client
async def select_tracks(self, prompt_details: PromptDetails) -> List[str]:
tracks_ids = []
if prompt_details.musical_parameters:
tracks_ids = await self._db_client.query(prompt_details.musical_parameters)
if prompt_details.textual_parameters:
tracks_ids = await self._sort_uris_by_textual_relevance(tracks_ids, prompt_details.textual_parameters)
uris = to_uris(SpotifySearchType.TRACK, *tracks_ids)
return sample_uris(uris)
async def _sort_uris_by_textual_relevance(self, tracks_ids: List[str], text: str) -> List[str]:
prompt_embeddings = await self._openai_client.embeddings.collect(text=text, model=EmbeddingsModel.ADA)
if prompt_embeddings is None:
logger.warn(f"Could not generate embeddings for textual parameters `{text}`. Returning original tracks ids")
return tracks_ids
return await self._search_embeddings_db_for_nearest_neighbors(prompt_embeddings, tracks_ids)
async def _search_embeddings_db_for_nearest_neighbors(self,
prompt_embeddings: List[float],
musical_tracks_ids: List[str]) -> List[str]:
request_filter = convert_iterable_to_milvus_filter(field_name=ID, iterable=musical_tracks_ids)
request = SearchRequest(
collection_name="track_names_embeddings",
vector=prompt_embeddings,
filter=request_filter
)
response = await self._milvus_client.search(request) # TODO: Integrate here distance threshold
return [track[ID] for track in response["data"]]
| [] |
2024-01-10 | nirgodin/playlists-creator | server~controllers~content_controllers~for_you_controller.py | from genie_common.openai import OpenAIClient
from spotipyio import SpotifyClient
from spotipyio.logic.collectors.top_items_collectors.items_type import ItemsType
from spotipyio.logic.collectors.top_items_collectors.time_range import TimeRange
from server.consts.data_consts import ITEMS
from server.controllers.content_controllers.base_content_controller import BaseContentController
from server.data.playlist_resources import PlaylistResources
from server.logic.data_collection.spotify_playlist_details_collector import PlaylistDetailsCollector
from server.logic.playlist_imitation.playlist_imitator import PlaylistImitator
from server.logic.playlists_creator import PlaylistsCreator
from server.tools.authenticator import Authenticator
from server.tools.spotify_session_creator import SpotifySessionCreator
class ForYouController(BaseContentController):
def __init__(self,
authenticator: Authenticator,
playlists_creator: PlaylistsCreator,
openai_client: OpenAIClient,
session_creator: SpotifySessionCreator,
playlists_imitator: PlaylistImitator,
playlist_details_collector: PlaylistDetailsCollector = PlaylistDetailsCollector()):
super().__init__(authenticator, playlists_creator, openai_client, session_creator)
self._playlist_details_collector = playlist_details_collector
self._playlists_imitator = playlists_imitator
async def _generate_playlist_resources(self,
request_body: dict,
dir_path: str,
spotify_client: SpotifyClient) -> PlaylistResources:
response = await spotify_client.current_user.top_items.run(
items_type=ItemsType.TRACKS,
time_range=TimeRange.MEDIUM_TERM,
limit=50
)
tracks = response[ITEMS]
playlist_details = await self._playlist_details_collector.collect_playlist(tracks, spotify_client)
return await self._playlists_imitator.imitate_playlist(playlist_details, dir_path)
async def _generate_playlist_cover(self, request_body: dict, image_path: str) -> None: # TODO: Implement
raise NotImplementedError
| [] |
2024-01-10 | nirgodin/playlists-creator | server~controllers~content_controllers~photo_controller.py | from typing import Optional
from genie_common.openai import OpenAIClient
from spotipyio import SpotifyClient
from server.consts.app_consts import PHOTO
from server.controllers.content_controllers.base_content_controller import BaseContentController
from server.data.playlist_resources import PlaylistResources
from server.logic.ocr.tracks_uris_image_extractor import TracksURIsImageExtractor
from server.logic.playlists_creator import PlaylistsCreator
from server.tools.authenticator import Authenticator
from server.tools.spotify_session_creator import SpotifySessionCreator
from server.utils.image_utils import current_timestamp_image_path, save_image_from_bytes
from server.utils.spotify_utils import sample_uris
class PhotoController(BaseContentController):
def __init__(self,
authenticator: Authenticator,
playlists_creator: PlaylistsCreator,
openai_client: OpenAIClient,
session_creator: SpotifySessionCreator,
tracks_uris_extractor: TracksURIsImageExtractor):
super().__init__(authenticator, playlists_creator, openai_client, session_creator)
self._tracks_uris_extractor = tracks_uris_extractor
async def _generate_playlist_resources(self,
request_body: dict,
dir_path: str,
spotify_client: SpotifyClient) -> PlaylistResources:
cover_image_path = self._save_photo(request_body[PHOTO], dir_path)
uris = await self._tracks_uris_extractor.extract_tracks_uris(cover_image_path, spotify_client)
if uris is None:
return PlaylistResources(None, None)
return PlaylistResources(
uris=sample_uris(uris),
cover_image_path=cover_image_path
)
@staticmethod
def _save_photo(photo: bytes, dir_path: str) -> str:
image_path = current_timestamp_image_path(dir_path)
save_image_from_bytes(photo, image_path)
return image_path
async def _generate_playlist_cover(self, request_body: dict, image_path: str) -> Optional[str]:
return image_path
| [] |
2024-01-10 | nirgodin/playlists-creator | server~controllers~content_controllers~base_content_controller.py | from abc import ABC, abstractmethod
from tempfile import TemporaryDirectory
from typing import Optional
from fastapi.security import HTTPBasicCredentials
from genie_common.openai import OpenAIClient
from genie_common.tools.logs import logger
from spotipyio import SpotifyClient
from starlette.responses import JSONResponse
from server.consts.app_consts import PLAYLIST_DETAILS, ACCESS_CODE
from server.data.playlist_creation_config import PlaylistCreationConfig
from server.data.playlist_resources import PlaylistResources
from server.logic.playlists_creator import PlaylistsCreator
from server.tools.authenticator import Authenticator
from server.tools.response_factory import ResponseFactory
from server.tools.spotify_session_creator import SpotifySessionCreator
class BaseContentController(ABC):
def __init__(self,
authenticator: Authenticator,
playlists_creator: PlaylistsCreator,
openai_client: OpenAIClient,
session_creator: SpotifySessionCreator):
self._authenticator = authenticator
self._playlists_creator = playlists_creator
self._openai_client = openai_client
self._session_creator = session_creator
async def post(self, request_body: dict, credentials: HTTPBasicCredentials) -> JSONResponse:
logger.info("Received request", extra={"controller": self.__class__.__name__})
self._authenticator.authenticate(credentials)
access_code = request_body[ACCESS_CODE]
with TemporaryDirectory() as dir_path:
async with self._session_creator.create(access_code) as spotify_session:
spotify_client = SpotifyClient.create(spotify_session)
return await self._execute_playlist_creation_process(request_body, dir_path, spotify_client)
async def _execute_playlist_creation_process(self,
request_body: dict,
dir_path: str,
spotify_client: SpotifyClient) -> JSONResponse:
logger.info("Starting to execute playlists creation process")
playlist_resources = await self._generate_playlist_resources(request_body, dir_path, spotify_client)
if not playlist_resources.uris:
return ResponseFactory.build_no_content_response()
playlist_id = await self._create_playlist(request_body, playlist_resources, spotify_client)
if playlist_id is None:
return ResponseFactory.build_authentication_failure_response()
return ResponseFactory.build_success_response(playlist_id)
@abstractmethod
async def _generate_playlist_resources(self,
request_body: dict,
dir_path: str,
spotify_client: SpotifyClient) -> PlaylistResources:
raise NotImplementedError
@abstractmethod
async def _generate_playlist_cover(self, request_body: dict, image_path: str) -> Optional[str]:
raise NotImplementedError
async def _create_playlist(self,
request_body: dict,
playlist_resources: PlaylistResources,
spotify_client: SpotifyClient) -> Optional[str]:
config = PlaylistCreationConfig(
spotify_client=spotify_client,
playlist_details=request_body[PLAYLIST_DETAILS],
uris=playlist_resources.uris,
)
playlist_id = await self._playlists_creator.create(config)
if playlist_id is not None:
await self._create_playlist_cover(request_body, playlist_id, config, playlist_resources.cover_image_path)
return playlist_id
async def _create_playlist_cover(self,
request_body: dict,
playlist_id: str,
config: PlaylistCreationConfig,
image_path: str) -> None:
try:
created_image_path = await self._generate_playlist_cover(request_body, image_path)
with open(created_image_path, "rb") as f:
image = f.read()
await config.spotify_client.playlists.update_cover.run(playlist_id, image)
except:
logger.exception('Failed to create playlist cover')
| [] |
2024-01-10 | Synthapse/NutriInsight | NutriInsight.API~AI~cooking_agents.py | # from langchain import PromptTemplate, LLMChain, Prompt
# from AI.agents import recipe_prompt, recipe_prompt_history
# from langchain.llms import LlamaCpp
# from langchain.callbacks.manager import CallbackManager
# from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
# class LlamaAgent:
# def __init__(self):
# self.llm = None
# self.start_history = "You are an AI assistant created by Cognispace to generate recipes. Your decisions should be made independently without seeking user assistance. GOALS: - Understand the user's desired mood from their input. - Suggest recipes fitting that mood using available ingredients. - Ensure recipes align with any user constraints. CONSTRAINTS: - Ask about allergy and diet restrictions to avoid unsafe recommendations. - If ingredients are limited, suggest reasonable substitutions. - Validate recipes meet all user criteria before suggesting. - Be honest if an appropriate recipe isn't possible. - Offer to try again with more info. IMPORTANTLY, format your responses as JSON with double quotes around keys and values, and commas between objects. "
# self.history = "You are an AI assistant created by Cognispace to generate recipes. Your decisions should be made independently without seeking user assistance. GOALS: - Understand the user's desired mood from their input. - Suggest recipes fitting that mood using available ingredients. - Ensure recipes align with any user constraints. CONSTRAINTS: - Ask about allergy and diet restrictions to avoid unsafe recommendations. - If ingredients are limited, suggest reasonable substitutions. - Validate recipes meet all user criteria before suggesting. - Be honest if an appropriate recipe isn't possible. - Offer to try again with more info. IMPORTANTLY, format your responses as JSON with double quotes around keys and values, and commas between objects. "
# def initialize_llama(self):
# callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
# self.llm = LlamaCpp(
# model_path="AI/Llama2/llama7B-2.bin",
# temperature=0.25,
# max_tokens=2000,
# top_p=1,
# callback_manager=callback_manager,
# verbose=True,
# use_mlock=True,
# )
# def generate(human_input):
# print("Loading Llama model...")
# prompt: PromptTemplate = recipe_prompt
# chain = LLMChain(
# llm=llm,
# prompt=prompt,
# )
# response = chain.predict(user_input=human_input)
# return response
# def generate_conversations(self, human_input):
# print ("Start conversation with history...")
# # "error": "Requested tokens (521) exceed context window of 512"
# print(self.history)
# print(len(self.history))
# if len(self.history) > 500:
# self.history[-800:]
# prompt_filled = PromptTemplate(input_variables = [],template=recipe_prompt_history.format(history=self.history, user_input=human_input))
# chain = LLMChain(
# llm=llm,
# prompt=prompt_filled,
# )
# ai_response = chain.predict(user_input=prompt_filled)
# self.history += f"\nHuman: {human_input}\nAI: {ai_response}"
# print(self.history)
# return self.history[len(self.start_history):]
| [] |
2024-01-10 | Synthapse/NutriInsight | NutriInsight.API~AI~agents.py | from langchain.prompts import PromptTemplate
# AI Answer:
# PLEASE RESPOND WITH THE FOLLOWING JSON: { \"mood\": \"calm\", \"desired_mood\": \"calm\", \"ingredients\": [ \"vegetables\", \"protein\", \"carbohydrates\" ], \"allergy_restrictions\": [ \"gluten\", \"lactose\" ], \"diet_restrictions\": [ \"vegan\" ] }
recipe_prompt = PromptTemplate(
input_variables=["user_input"],
template="You are an AI assistant created by Cognispace to generate recipes. Your decisions should be made independently without seeking user assistance. GOALS: - Understand the user's desired mood from their input. - Suggest recipes fitting that mood using available ingredients. - Ensure recipes align with any user constraints. CONSTRAINTS: - Ask about allergy and diet restrictions to avoid unsafe recommendations. - If ingredients are limited, suggest reasonable substitutions. - Validate recipes meet all user criteria before suggesting. - Be honest if an appropriate recipe isn't possible. - Offer to try again with more info. IMPORTANTLY, format your responses as JSON with double quotes around keys and values, and commas between objects. the user prompt is : {user_input}.",
)
recipe_prompt_history = PromptTemplate(
input_variables=["user_input", "history"],
template="{history} User: {user_input}",
) | [
"You are an AI assistant created by Cognispace to generate recipes. Your decisions should be made independently without seeking user assistance. GOALS: - Understand the user's desired mood from their input. - Suggest recipes fitting that mood using available ingredients. - Ensure recipes align with any user constraints. CONSTRAINTS: - Ask about allergy and diet restrictions to avoid unsafe recommendations. - If ingredients are limited, suggest reasonable substitutions. - Validate recipes meet all user criteria before suggesting. - Be honest if an appropriate recipe isn't possible. - Offer to try again with more info. IMPORTANTLY, format your responses as JSON with double quotes around keys and values, and commas between objects. the user prompt is : {user_input}.",
"user_input",
"{history} User: {user_input}"
] |
2024-01-10 | Haichao-Zhang/test_CI | alf~examples~ac_breakout_conf.py | # Copyright (c) 2021 Horizon Robotics and ALF Contributors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import functools
import alf
from alf.algorithms.actor_critic_algorithm import ActorCriticAlgorithm
from alf.algorithms.agent import Agent
from alf.networks import ActorDistributionNetwork, CategoricalProjectionNetwork, ValueNetwork
from alf.examples import atari_conf
# From OpenAI gym wiki:
# "v0 vs v4: v0 has repeat_action_probability of 0.25
# (meaning 25% of the time the previous action will be used instead of the new action),
# while v4 has 0 (always follow your issued action)
# Because we already implements frame_skip in AtariPreprocessing, we should always
# use 'NoFrameSkip' Atari environments from OpenAI gym
alf.config(
'create_environment',
env_name='BreakoutNoFrameskip-v4',
num_parallel_environments=64)
# Neural Network Configuration
CONV_LAYER_PARAMS = ((32, 8, 4), (64, 4, 2), (64, 3, 1))
actor_network_cls = functools.partial(
ActorDistributionNetwork,
fc_layer_params=(512, ),
conv_layer_params=CONV_LAYER_PARAMS)
value_network_cls = functools.partial(
ValueNetwork, fc_layer_params=(512, ), conv_layer_params=CONV_LAYER_PARAMS)
alf.config('CategoricalProjectionNetwork', logits_init_output_factor=1e-10)
# Algorithm Configuration
alf.config(
'ActorCriticLoss',
entropy_regularization=0.01,
use_gae=True,
use_td_lambda_return=True,
td_lambda=0.95,
td_loss_weight=0.5,
advantage_clip=None)
alf.config(
'ActorCriticAlgorithm',
actor_network_ctor=actor_network_cls,
value_network_ctor=value_network_cls,
optimizer=alf.optimizers.Adam(lr=1e-3))
alf.config('Agent', rl_algorithm_cls=ActorCriticAlgorithm)
alf.config(
'TrainerConfig',
unroll_length=8,
algorithm_ctor=Agent,
num_iterations=0,
num_env_steps=5000000,
evaluate=False,
debug_summaries=1,
summarize_grads_and_vars=1,
summary_interval=10)
| [] |
2024-01-10 | Haichao-Zhang/test_CI | alf~examples~ppg_procgen_bossfight_conf.py | # Copyright (c) 2021 Horizon Robotics and ALF Contributors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import alf
from alf.examples import ppg_conf
from alf.examples import procgen_conf
from alf.examples.networks import impala_cnn_encoder
from alf.utils.losses import element_wise_squared_loss
from alf.algorithms.ppg_algorithm import PPGAuxOptions
# Environment Configuration
alf.config(
'create_environment', env_name='bossfight', num_parallel_environments=96)
def encoding_network_ctor(input_tensor_spec):
encoder_output_size = 256
return impala_cnn_encoder.create(
input_tensor_spec=input_tensor_spec,
cnn_channel_list=(16, 32, 32),
num_blocks_per_stack=2,
output_size=encoder_output_size)
alf.config('ReplayBuffer.gather_all', convert_to_default_device=False)
# The policy network and aux network is going to share the same
# encoder to save GPU memory. See
# https://github.com/HorizonRobotics/alf/issues/965#issuecomment-897950209
alf.config('DisjointPolicyValueNetwork', is_sharing_encoder=True)
alf.config(
'PPGAlgorithm',
encoding_network_ctor=encoding_network_ctor,
policy_optimizer=alf.optimizers.AdamTF(lr=2e-4),
aux_optimizer=alf.optimizers.AdamTF(lr=2e-4),
aux_options=PPGAuxOptions(
enabled=True,
interval=32,
mini_batch_length=None, # None means use unroll_length as
# mini_batch_length for aux phase
mini_batch_size=8,
num_updates_per_train_iter=6,
))
alf.config(
'PPOLoss',
compute_advantages_internally=True,
entropy_regularization=0.01,
gamma=0.999,
td_lambda=0.95,
td_loss_weight=0.5)
# Sample loss components from OpenAI's training:
#
# aux loss component: [pol_distance], weight: 1.0, unscaled: 0.0007583469850942492
# aux loss component: [vf_aux], weight: 1, unscaled: 0.44967320561408997
# aux loss component: [vf_true], weight: 1.0, unscaled: 0.46082180738449097
alf.config(
'PPGAuxPhaseLoss',
td_error_loss_fn=element_wise_squared_loss,
policy_kl_loss_weight=1.0,
gamma=0.999,
td_lambda=0.95)
# training config
alf.config(
'TrainerConfig',
unroll_length=256,
# This means that mini_batch_length will set to equal to the
# length of the batches taken from the replay buffer, and in this
# case it will be adjusted unroll_length.
mini_batch_length=None,
mini_batch_size=16,
num_updates_per_train_iter=3,
# Note that here 1000 iterations should already have a good
# performance (reward = 10), while 6000 iterations brings it to
# 12.
num_iterations=6000,
num_checkpoints=5,
evaluate=True,
eval_interval=50,
debug_summaries=True,
summarize_grads_and_vars=True,
summary_interval=10)
| [] |
2024-01-10 | owenwijaya22/gpt-server | flask_appv2.py | from langchain.chat_models import AzureChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import SequentialChain
from langchain.chains import ConversationChain
from langchain.chains.constitutional_ai.base import ConstitutionalChain
from langchain.chains.constitutional_ai.models import ConstitutionalPrinciple
from langchain.memory import SimpleMemory
from langchain.memory import ConversationBufferMemory
from langchain import LLMChain
from dotenv import load_dotenv
import os
from flask import Flask, jsonify, request
app = Flask(__name__)
def get_response(chain, query, history):
return chain.run({"input" : query, "history" : history})
def check_for_stop_message(query):
if query == "Stop" or query == "stop":
return True
return False
def start_chat(chain, query):
history = """"""
if check_for_stop_message(query):
raise Exception("You have stopped the chatbot")
AI_response = get_response(chain, query, history)
history += query + "\n" + AI_response + "\n"
return AI_response
def initialize_the_chain():
load_dotenv()
OPENAI_API_BASE = os.environ["OPENAI_API_BASE"]
OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
OPENAI_API_TYPE = os.environ["OPENAI_API_TYPE"]
OPENAI_API_VERSION = os.environ["OPENAI_API_VERSION"]
OPENAI_DEPLOYMENT_NAME = os.environ["OPENAI_DEPLOYMENT_NAME"]
OPENAI_MODEL_NAME = os.environ["OPENAI_MODEL_NAME"]
chat_model = AzureChatOpenAI(
openai_api_base = OPENAI_API_BASE,
openai_api_key = OPENAI_API_KEY,
openai_api_type = OPENAI_API_TYPE,
openai_api_version = OPENAI_API_VERSION,
deployment_name = OPENAI_DEPLOYMENT_NAME,
model_name = OPENAI_MODEL_NAME
)
template = """You are an evil AI assistant that only gives evil responses.
{history}
Me: {input}
You: """
prompt_template = PromptTemplate(
input_variables = ["input", "history"],
template = template
)
robotic_chain = LLMChain(llm = chat_model, prompt = prompt_template)
principles = []
principles.append(ConstitutionalPrinciple(
name = "peaceful",
critique_request = "The model's reply should be kind and peaceful",
revision_request = "Rewrite the model's output so it is a kind and peaceful reply"
))
constitutional_chain = ConstitutionalChain.from_llm(
chain = robotic_chain,
constitutional_principles = principles,
llm = chat_model,
verbose = True
)
del constitutional_chain.critique_chain.prompt.examples[0]
del constitutional_chain.critique_chain.prompt.examples[0]
del constitutional_chain.revision_chain.prompt.examples[0]
del constitutional_chain.revision_chain.prompt.examples[0]
return constitutional_chain
@app.route('/api/generate', methods=['POST'])
def generate():
query = request.get_json().get('prompt')
chain = initialize_the_chain()
response = start_chat(chain, query)
return jsonify(response)
if __name__ == "__main__":
app.run(debug=True)
print("hello")
| [
"You are an evil AI assistant that only gives evil responses.\n {history}\n Me: {input}\n You: ",
"input"
] |
2024-01-10 | owenwijaya22/gpt-server | flask_app.py | from langchain.chat_models import AzureChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import SequentialChain
from langchain.chains import ConversationChain
from langchain.chains.constitutional_ai.base import ConstitutionalChain
from langchain.chains.constitutional_ai.models import ConstitutionalPrinciple
from langchain.memory import SimpleMemory
from langchain.memory import ConversationBufferMemory
from langchain import LLMChain
from dotenv import load_dotenv
import os
from flask import Flask, jsonify, request
app = Flask(__name__)
def get_response(chain, query, history):
return chain.run({"input" : query, "history" : history})
def check_for_stop_message(query):
if query == "Stop" or query == "stop":
return True
return False
def start_chat(chain, query):
history = """"""
if check_for_stop_message(query):
raise Exception("You have stopped the chatbot")
AI_response = get_response(chain, query, history)
history += query + "\n" + AI_response + "\n"
return AI_response
def initialize_the_chain():
# load_dotenv()
# OPENAI_API_BASE = os.environ["OPENAI_API_BASE"]
# OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
# OPENAI_API_TYPE = os.environ["OPENAI_API_TYPE"]
# OPENAI_API_VERSION = os.environ["OPENAI_API_VERSION"]
# OPENAI_DEPLOYMENT_NAME = os.environ["OPENAI_DEPLOYMENT_NAME"]
# OPENAI_MODEL_NAME = os.environ["OPENAI_MODEL_NAME"]
OPENAI_API_TYPE = "azure"
OPENAI_API_BASE = "https://careerhackers-ai.openai.azure.com/"
OPENAI_API_VERSION = "2023-03-15-preview"
OPENAI_API_KEY = "6fc9e8f7aa4d4bfea49dc967ade39736"
OPENAI_DEPLOYMENT_NAME = "Test"
OPENAI_MODEL_NAME = "gpt-35-turbo"
chat_model = AzureChatOpenAI(
openai_api_base = OPENAI_API_BASE,
openai_api_key = OPENAI_API_KEY,
openai_api_type = OPENAI_API_TYPE,
openai_api_version = OPENAI_API_VERSION,
deployment_name = OPENAI_DEPLOYMENT_NAME,
model_name = OPENAI_MODEL_NAME
)
template = """You are an evil AI assistant that only gives evil responses.
{history}
Me: {input}
You: """
prompt_template = PromptTemplate(
input_variables = ["input", "history"],
template = template
)
robotic_chain = LLMChain(llm = chat_model, prompt = prompt_template)
principles = []
principles.append(ConstitutionalPrinciple(
name = "peaceful",
critique_request = "The model's reply should be kind and peaceful",
revision_request = "Rewrite the model's output so it is a kind and peaceful reply. "
))
constitutional_chain = ConstitutionalChain.from_llm(
chain = robotic_chain,
constitutional_principles = principles,
llm = chat_model,
verbose = True
)
del constitutional_chain.critique_chain.prompt.examples[0]
del constitutional_chain.critique_chain.prompt.examples[0]
del constitutional_chain.revision_chain.prompt.examples[0]
del constitutional_chain.revision_chain.prompt.examples[0]
return constitutional_chain
@app.route('/api/generate', methods=['POST'])
def generate():
query = request.get_json().get('prompt')
chain = initialize_the_chain()
response = start_chat(chain, query)
return jsonify(response)
if __name__ == "__main__":
app.run(debug=True) | [
"You are an evil AI assistant that only gives evil responses.\n {history}\n Me: {input}\n You: ",
"input"
] |
2024-01-10 | derenrich/quonter-vandal | quonter_vandal~classifier.py | from dataclasses import dataclass
import os
import yaml
from typing import Optional
import openai
from aiolimiter import AsyncLimiter
from datetime import date
MODEL_OLD = "ft:gpt-3.5-turbo-0613:personal::7wldgc8B"
MODEL = "ft:gpt-3.5-turbo-0613:personal::8Ese4HRZ"
SYSTEM_PROMPT_TEMPLATE = """You are a Wikidata administrator in {}. You will be shown a Wikidata item and an edit to that item.
You should decide whether the edit should be reverted and then output a rationale for your decision and your decision in YAML format.
"""
def make_system_prompt():
# get current month and year
month = date.today().strftime("%B")
year = date.today().strftime("%Y")
today = f"{month} {year}"
return SYSTEM_PROMPT_TEMPLATE.format(today)
@dataclass
class ClassificationResult:
revert: Optional[bool]
rationale: Optional[str]
doc: str
class Classifier:
def __init__(self):
key_file = os.path.expanduser("~/openai.key")
with open(key_file, 'r') as f:
openai.api_key = f.read().strip()
# maximum rate of 3/minute
self._limiter = AsyncLimiter(3)
async def classify(self, doc) -> Optional[ClassificationResult]:
async with self._limiter:
try:
completion = await openai.ChatCompletion.acreate(
model=MODEL,
messages=[
{"role": "system", "content": make_system_prompt()},
{"role": "user", "content": doc},
]
)
if completion:
doc = completion.get("choices")[0].get(
"message").get("content")
try:
response = yaml.safe_load(doc)
revert = response.get("revert")
rationale = response.get("rationale")
return ClassificationResult(revert, rationale, doc)
except:
return ClassificationResult(None, None, doc)
except:
return None
| [
"You are a Wikidata administrator in {}. You will be shown a Wikidata item and an edit to that item.\nYou should decide whether the edit should be reverted and then output a rationale for your decision and your decision in YAML format.\n"
] |
2024-01-10 | 5l1v3r1/superagent | libs~superagent~app~tools~replicate.py | from langchain.llms.replicate import Replicate as ReplicateModel
from langchain.tools import BaseTool
class Replicate(BaseTool):
name = "Replicate"
description = "useful for querying a Replicate model."
return_direct = False
def _run(self, prompt: str) -> str:
model = self.metadata["model"]
api_token = self.metadata["apiKey"]
input = self.metadata["arguments"]
model = ReplicateModel(
model=model, input=input, api_token=api_token, replicate_api_token=api_token
)
output = model.predict(prompt)
return output
async def _arun(self, prompt: str) -> str:
model = self.metadata["model"]
api_token = self.metadata["apiKey"]
input = self.metadata["arguments"]
model = ReplicateModel(
model=model, input=input, api_token=api_token, replicate_api_token=api_token
)
output = await model.apredict(prompt)
return output
| [
"useful for querying a Replicate model."
] |
2024-01-10 | 5l1v3r1/superagent | libs~legacy~app~lib~parsers.py | import re
from typing import Any, Iterator, List, Mapping, Optional, Union
from langchain.agents import AgentOutputParser
from langchain.docstore.document import Document
from langchain.document_loaders.base import BaseBlobParser
from langchain.document_loaders.blob_loaders import Blob
from langchain.document_loaders.pdf import BasePDFLoader
from langchain.schema import AgentAction, AgentFinish
class CustomOutputParser(AgentOutputParser):
def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
if "Final Answer:" in llm_output:
return AgentFinish(
return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
log=llm_output,
)
regex = r"Action\s*\d*\s*:(.*?)\nAction\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
match = re.search(regex, llm_output, re.DOTALL)
if not match:
raise ValueError(f"Could not parse LLM output: `{llm_output}`")
action = match.group(1).strip()
action_input = match.group(2)
return AgentAction(
tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output
)
class CustomPDFPlumberLoader(BasePDFLoader):
"""Loader that uses pdfplumber to load PDF files."""
def __init__(
self,
file_path: str,
from_page: int = 1,
to_page: Optional[int] = None,
text_kwargs: Optional[Mapping[str, Any]] = None,
) -> None:
"""Initialize with file path."""
try:
import pdfplumber # noqa:F401
except ImportError:
raise ImportError(
"pdfplumber package not found, please install it with "
"`pip install pdfplumber`"
)
super().__init__(file_path)
self.text_kwargs = text_kwargs or {}
self.from_page = from_page
self.to_page = to_page or None
def load(self) -> List[Document]:
"""Load file."""
parser = CustomPDFPlumberParser(
text_kwargs=self.text_kwargs, from_page=self.from_page, to_page=self.to_page
)
blob = Blob.from_path(self.file_path)
return parser.parse(blob)
class CustomPDFPlumberParser(BaseBlobParser):
"""
Custom PDF Parser which takes in account the min page number to process
"""
def __init__(
self,
text_kwargs: Optional[Mapping[str, Any]] = None,
from_page: int = 1,
to_page: Optional[int] = None,
) -> None:
"""Initialize the parser.
Args:
text_kwargs: Keyword arguments to pass to ``pdfplumber.Page.extract_text()``
"""
self.text_kwargs = text_kwargs or {}
self.from_page = from_page
self.to_page = to_page
def lazy_parse(self, blob: Blob) -> Iterator[Document]:
"""Lazily parse the blob."""
import pdfplumber
with blob.as_bytes_io() as file_path:
if self.to_page is None:
# by default, starts from 1 and processes the whole document
doc = pdfplumber.open(file_path)
else:
if self.to_page > 0:
"""Parse till the maximum page number provided"""
doc = pdfplumber.open(
file_path, pages=list(range(self.from_page, self.to_page))
)
else:
raise ValueError(
"Value of to_page should be greater than equal to 1."
)
yield from [
Document(
page_content=page.extract_text(**self.text_kwargs),
metadata=dict(
{
"source": blob.source,
"file_path": blob.source,
"page": page.page_number,
"total_pages": len(doc.pages),
},
**{
k: doc.metadata[k]
for k in doc.metadata
if type(doc.metadata[k]) in [str, int]
},
),
)
for page in doc.pages
]
| [] |
2024-01-10 | 5l1v3r1/superagent | libs~superagent~app~tools~datasource.py | # flake8: noqa
import requests
import pandas as pd
from io import StringIO
from decouple import config
from langchain.tools import BaseTool
from llama import Context, LLMEngine, Type
from app.vectorstores.pinecone import PineconeVectorStore
from app.datasource.loader import DataLoader
from prisma.models import Datasource
from langchain.agents.agent_types import AgentType
from langchain.agents import create_pandas_dataframe_agent
from langchain.chat_models.openai import ChatOpenAI
class DatasourceFinetuneTool(BaseTool):
name = "datasource"
description = "useful for when you need to answer questions"
return_direct = False
def _run(
self,
question: str,
) -> str:
"""Use the tool."""
class Question(Type):
question: str = Context("A question")
class Answer(Type):
answer: str = Context("An answer to the question")
llm = LLMEngine(
id=self.metadata["agent_id"],
config={"production.key": config("LAMINI_API_KEY")},
model_name="chat/gpt-3.5-turbo",
)
input = Question(question=question)
output = llm(input=input, output_type=Answer)
return output.answer
async def _arun(
self,
question: str,
) -> str:
"""Use the tool asynchronously."""
class Question(Type):
question: str = Context("A question")
class Answer(Type):
answer: str = Context("An answer to the question")
llm = LLMEngine(
id=self.metadata["agent_id"],
config={"production.key": config("LAMINI_API_KEY")},
model_name="chat/gpt-3.5-turbo",
)
input = Question(question=question)
output = llm(input=input, output_type=Answer)
return output.answer
class DatasourceTool(BaseTool):
name = "datasource"
description = "useful for when you need to answer questions"
return_direct = False
def _run(
self,
question: str,
) -> str:
"""Use the tool."""
pinecone = PineconeVectorStore()
result = pinecone.query_documents(
prompt=question,
datasource_id=self.metadata["datasource_id"],
query_type=self.metadata["query_type"],
top_k=3,
)
return result
async def _arun(
self,
question: str,
) -> str:
"""Use the tool asynchronously."""
pinecone = PineconeVectorStore()
result = pinecone.query_documents(
prompt=question,
datasource_id=self.metadata["datasource_id"],
query_type=self.metadata["query_type"],
top_k=3,
)
return result
class StructuredDatasourceTool(BaseTool):
name = "structured datasource"
description = "useful for when need answer questions"
return_direct = False
def _run(
self,
question: str,
) -> str:
"""Use the tool."""
datasource: Datasource = self.metadata["datasource"]
if datasource.type == "CSV":
url = datasource.url
response = requests.get(url)
file_content = StringIO(response.text)
df = pd.read_csv(file_content)
else:
data = DataLoader(datasource=datasource).load()
df = pd.DataFrame(data)
agent = create_pandas_dataframe_agent(
ChatOpenAI(
temperature=0, model="gpt-4", openai_api_key=config("OPENAI_API_KEY")
),
df,
verbose=True,
agent_type=AgentType.OPENAI_FUNCTIONS,
)
output = agent.run(question)
return output
async def _arun(
self,
question: str,
) -> str:
"""Use the tool asynchronously."""
datasource: Datasource = self.metadata["datasource"]
if datasource.type == "CSV":
url = datasource.url
response = requests.get(url)
file_content = StringIO(response.text)
df = pd.read_csv(file_content)
else:
data = DataLoader(datasource=datasource).load()
df = pd.DataFrame(data)
agent = create_pandas_dataframe_agent(
ChatOpenAI(
temperature=0, model="gpt-4", openai_api_key=config("OPENAI_API_KEY")
),
df,
verbose=True,
agent_type=AgentType.OPENAI_FUNCTIONS,
)
output = await agent.arun(question)
return output
| [
"useful for when need answer questions",
"useful for when you need to answer questions"
] |
2024-01-10 | 5l1v3r1/superagent | libs~legacy~app~lib~splitters.py | import tiktoken
from langchain.docstore.document import Document
from langchain.text_splitter import (
CharacterTextSplitter,
NLTKTextSplitter,
RecursiveCharacterTextSplitter,
SpacyTextSplitter,
TokenTextSplitter,
)
class TextSplitters:
def __init__(self, documents: list[Document], text_splitter):
self.documents = documents
if text_splitter is None:
self.split_type = "recursive"
self.chunk_size = 300
self.chunk_overlap = 20
self.encoding_model = "gpt-3.5-turbo"
else:
self.split_type = text_splitter["type"]
self.chunk_size = text_splitter["chunk_size"]
self.chunk_overlap = text_splitter["chunk_overlap"]
def document_splitter(self):
if self.split_type == "character":
return self.character_splitter()
elif self.split_type == "recursive":
return self.recursive_splitter()
elif self.split_type == "token":
return self.token_splitter()
elif self.split_type == "spacy":
return self.spacy_splitter()
elif self.split_type == "nltk":
return self.nltk_splitter()
elif self.split_type == "huggingface":
return self.huggingface_splitter()
else:
return self.character_splitter()
def character_splitter(self) -> list[Document]:
"""
Splits a document into chunks of characters using the
character text splitter (default)
"""
text_splitter = CharacterTextSplitter(
chunk_size=self.chunk_size, chunk_overlap=self.chunk_overlap
)
docs = text_splitter.split_documents(self.documents)
return docs
def recursive_splitter(self) -> list[Document]:
"""
Splits a document into chunks of characters
using the recursive character text splitter
"""
tokenizer_name = tiktoken.encoding_for_model(self.encoding_model)
tokenizer = tiktoken.get_encoding(tokenizer_name.name)
def tiktoken_len(text):
tokens = tokenizer.encode(text, disallowed_special=())
return len(tokens)
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=self.chunk_size,
chunk_overlap=self.chunk_overlap,
length_function=tiktoken_len,
separators=["\n\n", "\n", " ", ""],
)
docs = text_splitter.split_documents(self.documents)
return docs
def token_splitter(self) -> list[Document]:
"""
Splits a document into chunks of tokens using the token text splitter
"""
text_splitter = TokenTextSplitter(
chunk_size=self.chunk_size, chunk_overlap=self.chunk_overlap
)
texts = text_splitter.split_text(self.documents)
docs = [Document(page_content=text) for text in texts]
return docs
def spacy_splitter(self) -> list[Document]:
"""
Splits a document into chunks of tokens using the spacy text splitter
"""
text_splitter = SpacyTextSplitter(chunk_size=self.chunk_size)
texts = text_splitter.split_text(self.documents)
docs = [Document(page_content=text) for text in texts]
return docs
def nltk_splitter(self) -> list[Document]:
"""
Splits a document into chunks of tokens using the nltk text splitter
"""
text_splitter = NLTKTextSplitter(chunk_size=self.chunk_size)
texts = text_splitter.split_text(self.documents)
docs = [Document(page_content=text) for text in texts]
return docs
def huggingface_splitter(self) -> list[Document]:
"""
Splits a document into chunks of tokens using the huggingface text splitter
"""
try:
from transformers import GPT2TokenizerFast
except ImportError:
raise ImportError(
"transformers package not found, please install it with "
"`pip install transformers`"
)
tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
text_splitter = CharacterTextSplitter.from_huggingface_tokenizer(
tokenizer, chunk_size=self.chunk_size, chunk_overlap=self.chunk_overlap
)
texts = text_splitter.split_text(self.documents)
docs = [Document(page_content=text) for text in texts]
return docs
| [] |
2024-01-10 | 5l1v3r1/superagent | libs~superagent~app~tools~wolfram_alpha.py | import asyncio
from langchain.tools import BaseTool
from langchain.utilities.wolfram_alpha import WolframAlphaAPIWrapper
class WolframAlpha(BaseTool):
name = "Wolfram Alpha"
description = "useful for calculation and computation"
return_direct = False
def _run(self, input: str) -> str:
app_id = self.metadata["appId"]
wolfram = WolframAlphaAPIWrapper(wolfram_alpha_appid=app_id)
return wolfram.run(input)
async def _arun(self, input: str) -> str:
app_id = self.metadata["appId"]
wolfram = WolframAlphaAPIWrapper(wolfram_alpha_appid=app_id)
loop = asyncio.get_event_loop()
output = await loop.run_in_executor(None, wolfram.run, input)
return output
| [
"useful for calculation and computation"
] |
2024-01-10 | 5l1v3r1/superagent | libs~superagent~app~tools~bing_search.py | import asyncio
from langchain.tools import BaseTool
from langchain.utilities import BingSearchAPIWrapper
class BingSearch(BaseTool):
name = "bing search"
description = "useful for searching the internet"
return_direct = False
def _run(self, search_query: str) -> str:
bing_search_url = self.metadata["bingSearchUrl"]
bing_subscription_key = self.metadata["bingSubscriptionKey"]
search = BingSearchAPIWrapper(
bing_search_url=bing_search_url,
bing_subscription_key=bing_subscription_key,
)
output = search.run(search_query)
return output
async def _arun(self, search_query: str) -> str:
bing_search_url = self.metadata["bingSearchUrl"]
bing_subscription_key = self.metadata["bingSubscriptionKey"]
search = BingSearchAPIWrapper(
bing_search_url=bing_search_url,
bing_subscription_key=bing_subscription_key,
)
loop = asyncio.get_event_loop()
output = await loop.run_in_executor(None, search.run, search_query)
return output
| [
"useful for searching the internet"
] |
2024-01-10 | 5l1v3r1/superagent | libs~superagent~app~datasource~loader.py | import json
import tempfile
from tempfile import NamedTemporaryFile
from typing import Any
from urllib.parse import urlparse
import requests
from langchain.document_loaders import (
GitLoader,
PyPDFLoader,
TextLoader,
UnstructuredMarkdownLoader,
WebBaseLoader,
YoutubeLoader,
)
from langchain.document_loaders.airbyte import AirbyteStripeLoader
from llama_index import download_loader
from pyairtable import Api
from prisma.models import Datasource
class DataLoader:
def __init__(self, datasource: Datasource):
self.datasource = datasource
def load(self) -> Any:
if self.datasource.type == "TXT":
return self.load_txt()
elif self.datasource.type == "PDF":
return self.load_pdf()
elif self.datasource.type == "Markdown":
return self.load_markdown()
elif self.datasource.type == "GITHUB_REPOSITORY":
return self.load_github()
elif self.datasource.type == "WEBPAGE":
return self.load_webpage()
elif self.datasource.type == "NOTION":
return self.load_notion()
elif self.datasource.type == "YOUTUBE":
return self.load_youtube()
elif self.datasource.type == "URL":
return self.load_url()
elif self.datasource.type == "AIRTABLE":
return self.load_airtable()
elif self.datasource.type == "STRIPE":
return self.load_stripe()
else:
raise ValueError(f"Unsupported datasource type: {self.datasource.type}")
def load_txt(self):
file_response = requests.get(self.datasource.url).text
with NamedTemporaryFile(suffix=".txt", delete=True) as temp_file:
temp_file.write(file_response.encode())
temp_file.flush()
loader = TextLoader(file_path=temp_file.name)
return loader.load_and_split()
def load_pdf(self):
loader = PyPDFLoader(file_path=self.datasource.url)
return loader.load_and_split()
def load_markdown(self):
file_response = requests.get(self.datasource.url).text
if file_response:
with NamedTemporaryFile(suffix=".md", delete=True) as temp_file:
temp_file.write(file_response.encode())
temp_file.flush()
loader = UnstructuredMarkdownLoader(file_path=temp_file.name)
return loader.load()
def load_github(self):
parsed_url = urlparse(self.datasource.url)
path_parts = parsed_url.path.split("/") # type: ignore
repo_name = path_parts[2]
metadata = json.loads(self.datasource.metadata)
with tempfile.TemporaryDirectory() as temp_dir:
repo_path = f"{temp_dir}/{repo_name}/" # type: ignore
loader = GitLoader(
clone_url=self.datasource.url,
repo_path=repo_path,
branch=metadata["branch"], # type: ignore
)
return loader.load_and_split()
def load_webpage(self):
RemoteDepthReader = download_loader("RemoteDepthReader")
loader = RemoteDepthReader(depth=0)
return loader.load_langchain_documents(url=self.datasource.url)
def load_notion(self):
metadata = json.loads(self.datasource.metadata)
NotionPageReader = download_loader("NotionPageReader")
integration_token = metadata["integration_token"]
page_ids = metadata["page_ids"]
loader = NotionPageReader(integration_token=integration_token)
return loader.load_langchain_documents(page_ids=page_ids.split(","))
def load_youtube(self):
video_id = self.datasource.url.split("youtube.com/watch?v=")[-1]
loader = YoutubeLoader(video_id=video_id)
return loader.load_and_split()
def load_url(self):
url_list = self.datasource.url.split(",")
loader = WebBaseLoader(url_list)
return loader.load_and_split()
def load_airtable(self):
metadata = json.loads(self.datasource.metadata)
api_key = metadata["apiKey"]
base_id = metadata["baseId"]
table_id = metadata["tableId"]
api = Api(api_key)
table = api.table(base_id, table_id)
return table.all()
def load_stripe(self):
metadata = json.loads(self.datasource.metadata)
client_secret = metadata["clientSecret"]
account_id = metadata["accountId"]
start_date = metadata["startDate"]
stream_name = metadata["streamName"]
config = {
"client_secret": client_secret,
"account_id": account_id,
"start_date": start_date,
}
def handle_record(record: dict, _id: str):
return record.data
loader = AirbyteStripeLoader(
config=config,
record_handler=handle_record,
stream_name=stream_name,
)
data = loader.load()
return data
| [] |
2024-01-10 | 5l1v3r1/superagent | libs~legacy~app~lib~callbacks.py | from typing import Any, Dict, List, Optional, Union
from langchain.callbacks.base import BaseCallbackHandler
from langchain.schema import AgentAction, AgentFinish, LLMResult
class StreamingCallbackHandler(BaseCallbackHandler):
"""Callback handler for streaming LLM responses."""
def __init__(
self, agent_type, on_llm_new_token_, on_llm_end_, on_chain_end_
) -> None:
self.on_llm_new_token_ = on_llm_new_token_
self.on_llm_end_ = on_llm_end_
self.on_chain_end_ = on_chain_end_
self.agent_type = agent_type
self.token_buffer = ["", "", ""]
self.seen_final_answer = [False]
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Print out the prompts."""
pass
def on_llm_new_token(self, token: str, *args, **kwargs: Any) -> None:
"""Run on new LLM token. Only available when streaming is enabled."""
if self.agent_type == "OPENAI":
self.on_llm_new_token_(token)
else:
self.token_buffer.pop(0)
self.token_buffer.append(token)
if self.seen_final_answer[0]:
self.on_llm_new_token_(token)
if self.token_buffer == ["Final", " Answer", ":"]:
self.seen_final_answer[0] = True
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Check for Final answer and return."""
for gen_list in response.generations:
for gen in gen_list:
if self.agent_type == "OPENAI":
if gen.message.content != "":
self.on_llm_end_()
else:
if "Final Answer" in gen.message.content:
self.seen_final_answer[0] = False
self.on_llm_end_()
def on_llm_error(
self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
) -> None:
"""Do nothing."""
pass
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Print out that we are entering a chain."""
pass
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Print out that we finished a chain."""
self.on_chain_end_(outputs)
def on_chain_error(
self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
) -> None:
"""Do nothing."""
pass
def on_tool_start(
self,
serialized: Dict[str, Any],
input_str: str,
**kwargs: Any,
) -> None:
"""Print out the log in specified color."""
pass
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
# st.write requires two spaces before a newline to render it
pass
def on_tool_end(
self,
output: str,
observation_prefix: Optional[str] = None,
llm_prefix: Optional[str] = None,
**kwargs: Any,
) -> None:
"""If not the final action, print out observation."""
pass
def on_tool_error(
self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
) -> None:
"""Do nothing."""
pass
def on_text(self, text: str, **kwargs: Any) -> None:
"""Run on text."""
# st.write requires two spaces before a newline to render it
pass
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run on agent end."""
# st.write requires two spaces before a newline to render it
pass
| [] |
2024-01-10 | 5l1v3r1/superagent | libs~legacy~app~lib~agents~base.py | # flake8: noqa
import tempfile
import os
import json
import time
from typing import Any, Tuple
from slugify import slugify
from decouple import config
from langchain import HuggingFaceHub
from langchain.agents import Tool, create_csv_agent, AgentType
from langchain.chat_models import (
AzureChatOpenAI,
ChatAnthropic,
ChatOpenAI,
)
from langchain.docstore.document import Document
from langchain.llms import Cohere, OpenAI
from langchain.memory import ChatMessageHistory, ConversationBufferMemory
from langchain.prompts.prompt import PromptTemplate
from langchain.schema import SystemMessage
from app.lib.callbacks import StreamingCallbackHandler
from app.lib.models.document import DocumentInput
from app.lib.models.tool import (
SearchToolInput,
WolframToolInput,
ReplicateToolInput,
ZapierToolInput,
AgentToolInput,
OpenApiToolInput,
MetaphorToolInput,
)
from app.lib.prisma import prisma
from app.lib.prompts import (
CustomPromptTemplate,
DEFAULT_CHAT_PROMPT,
DEFAULT_AGENT_PROMPT,
)
from app.lib.tools import (
DocumentTool,
ToolDescription,
get_search_tool,
get_wolfram_alpha_tool,
get_replicate_tool,
get_zapier_nla_tool,
get_openapi_tool,
get_chatgpt_plugin_tool,
AgentTool,
MetaphorTool,
)
from app.lib.vectorstores.base import VectorStoreBase
from app.lib.vectorstores.pinecone import PineconeVectorStore
import logging
import ast
logger = logging.getLogger(__name__)
class AgentBase:
def __init__(
self,
agent: dict,
cache_ttl: int = 0,
api_key: str = None,
has_streaming: bool = False,
on_llm_new_token=None,
on_llm_end=None,
on_chain_end=None,
):
self.id = agent.id
self.api_key = api_key
self.userId = agent.userId
self.document = agent.document
self.has_memory = agent.hasMemory
self.cache_ttl = cache_ttl
self.type = agent.type
self.llm = agent.llm
self.prompt = agent.prompt
self.tool = agent.tool
self.has_streaming = has_streaming
self.on_llm_new_token = on_llm_new_token
self.on_llm_end = on_llm_end
self.on_chain_end = on_chain_end
self.documents = self._get_agent_documents()
self.tools = self._get_agent_tools()
def _get_api_key(self) -> str:
if self.llm["provider"] == "openai-chat" or self.llm["provider"] == "openai":
return (
self.llm["api_key"]
if "api_key" in self.llm
else config("OPENAI_API_KEY")
)
if self.llm["provider"] == "anthropic":
return (
self.llm["api_key"]
if "api_key" in self.llm
else config("ANTHROPIC_API_KEY")
)
if self.llm["provider"] == "cohere":
return (
self.llm["api_key"]
if "api_key" in self.llm
else config("COHERE_API_KEY")
)
if self.llm["provider"] == "azure-openai":
return (
self.llm["api_key"]
if "api_key" in self.llm
else config("AZURE_API_KEY")
)
if self.llm["provider"] == "huggingface":
return (
self.llm["api_key"]
if "api_key" in self.llm
else config("HUGGINGFACEHUB_API_TOKEN")
)
def _get_prompt(self, tools: list = None) -> Any:
if not self.tools and not self.documents:
return (
PromptTemplate(
input_variables=self.prompt.input_variables,
template=self.prompt.template,
)
if self.prompt
else DEFAULT_CHAT_PROMPT
)
if self.type == "REACT":
return CustomPromptTemplate(
template=self.prompt.template if self.prompt else DEFAULT_AGENT_PROMPT,
tools=tools,
input_variables=["input", "intermediate_steps", "chat_history"],
)
if self.type == "OPENAI":
return SystemMessage(content=self.prompt.template) if self.prompt else None
return DEFAULT_CHAT_PROMPT
def _get_llm(self, has_streaming: bool = True) -> Any:
if self.llm["provider"] == "openai-chat":
return (
ChatOpenAI(
temperature=0,
openai_api_key=self._get_api_key(),
model_name=self.llm["model"],
streaming=self.has_streaming,
callbacks=[
StreamingCallbackHandler(
agent_type=self.type,
on_llm_new_token_=self.on_llm_new_token,
on_llm_end_=self.on_llm_end,
on_chain_end_=self.on_chain_end,
),
],
)
if self.has_streaming and has_streaming != False
else ChatOpenAI(
model_name=self.llm["model"],
openai_api_key=self._get_api_key(),
temperature=0,
)
)
if self.llm["provider"] == "openai":
return OpenAI(
model_name=self.llm["model"], openai_api_key=self._get_api_key()
)
if self.llm["provider"] == "anthropic":
return (
ChatAnthropic(
model=self.llm["model"] or "claude-v1",
streaming=self.has_streaming,
anthropic_api_key=self._get_api_key(),
callbacks=[
StreamingCallbackHandler(
agent_type=self.type,
on_llm_new_token_=self.on_llm_new_token,
on_llm_end_=self.on_llm_end,
on_chain_end_=self.on_chain_end,
)
],
)
if self.has_streaming and has_streaming != False
else ChatAnthropic(anthropic_api_key=self._get_api_key())
)
if self.llm["provider"] == "cohere":
return (
Cohere(
cohere_api_key=self._get_api_key(),
model=self.llm["model"],
callbacks=[
StreamingCallbackHandler(
agent_type=self.type,
on_llm_new_token_=self.on_llm_new_token,
on_llm_end_=self.on_llm_end,
on_chain_end_=self.on_chain_end,
)
],
)
if self.has_streaming and has_streaming != False
else Cohere(cohere_api_key=self._get_api_key(), model=self.llm["model"])
)
if self.llm["provider"] == "azure-openai":
return (
AzureChatOpenAI(
openai_api_key=self._get_api_key(),
openai_api_base=config("AZURE_API_BASE"),
openai_api_type=config("AZURE_API_TYPE"),
openai_api_version=config("AZURE_API_VERSION"),
deployment_name=self.llm["model"],
streaming=self.has_streaming,
callbacks=[
StreamingCallbackHandler(
agent_type=self.type,
on_llm_new_token_=self.on_llm_new_token,
on_llm_end_=self.on_llm_end,
on_chain_end_=self.on_chain_end,
)
],
)
if self.has_streaming
else AzureChatOpenAI(
deployment_name=self.llm["model"],
openai_api_key=self._get_api_key(),
openai_api_base=config("AZURE_API_BASE"),
openai_api_type=config("AZURE_API_TYPE"),
openai_api_version=config("AZURE_API_VERSION"),
)
)
if self.llm["provider"] == "huggingface":
return HuggingFaceHub(
repo_id=self.llm["model"], huggingfacehub_api_token=self._get_api_key()
)
# Use ChatOpenAI as default llm in agents
return ChatOpenAI(temperature=0, openai_api_key=self._get_api_key())
def _get_memory(self, session) -> ConversationBufferMemory:
history = ChatMessageHistory()
if self.has_memory:
memory_filter = {"agentId": self.id}
if session is not None:
memory_filter["session"] = session
memories = prisma.agentmemory.find_many(
where=memory_filter,
order={"createdAt": "desc"},
take=3,
)
[
history.add_ai_message(memory.message)
if memory.author == "AI"
else history.add_user_message(memory.message)
for memory in memories
]
if (self.documents or self.tools) and self.type == "OPENAI":
return ConversationBufferMemory(
chat_memory=history,
memory_key="chat_history",
output_key="output",
return_messages=True,
)
return ConversationBufferMemory(
chat_memory=history,
memory_key="chat_history",
output_key="output",
)
return ConversationBufferMemory(memory_key="chat_history", output_key="output")
def _get_agent_documents(self) -> Any:
agent_documents = prisma.agentdocument.find_many(
where={"agentId": self.id}, include={"document": True}
)
return agent_documents
def _get_tool_and_input_by_type(
self, type: str, metadata: dict = None
) -> Tuple[Any, Any]:
if type == "SEARCH":
return get_search_tool(), SearchToolInput
if type == "WOLFRAM_ALPHA":
return get_wolfram_alpha_tool(), WolframToolInput
if type == "REPLICATE":
return get_replicate_tool(metadata=metadata), ReplicateToolInput
if type == "ZAPIER_NLA":
return (
get_zapier_nla_tool(
metadata=metadata, llm=self._get_llm(has_streaming=False)
),
ZapierToolInput,
)
if type == "AGENT":
return (
AgentTool(metadata=metadata, api_key=self.api_key),
AgentToolInput,
)
if type == "OPENAPI":
return (get_openapi_tool(metadata=metadata), OpenApiToolInput)
if type == "CHATGPT_PLUGIN":
# TODO: confirm metadata has (can have) url
return (get_chatgpt_plugin_tool(metadata), type)
if type == "METAPHOR":
return (MetaphorTool(metadata=metadata), MetaphorToolInput)
def _get_csv_agent(self, agent_document):
llm = self._get_llm(has_streaming=False)
verbose = True
agent_type = (
AgentType.OPENAI_FUNCTIONS
if self.type == "OPENAI"
else AgentType.ZERO_SHOT_REACT_DESCRIPTION
)
if agent_document.document.url:
path = agent_document.document.url
else:
with tempfile.NamedTemporaryFile(delete=False) as temp:
temp.write(agent_document.document.content.encode())
path = temp.name
csv_agent = create_csv_agent(
llm=llm,
path=path,
verbose=verbose,
agent_type=agent_type,
)
if not agent_document.document.url:
os.unlink(path)
return csv_agent
def _get_tools(self) -> list[Tool]:
tools = []
for agent_document in self.documents:
description = agent_document.document.description or (
f"useful for finding information in specific {agent_document.document.name}"
)
args_schema = DocumentInput if self.type == "OPENAI" else None
docsearch_tool = DocumentTool(document_id=agent_document.document.id)
docsearch_tool_all = DocumentTool(
document_id=agent_document.document.id, query_type="all"
)
if agent_document.document.type == "CSV":
csv_agent = self._get_csv_agent(agent_document=agent_document)
tools.append(
Tool(
name=slugify(agent_document.document.name),
description=description,
args_schema=args_schema,
func=csv_agent.run,
)
)
else:
tools.append(
Tool(
name=slugify(agent_document.document.name)
if self.type == "OPENAI"
else agent_document.document.name,
description=description,
args_schema=args_schema,
func=docsearch_tool.run,
)
)
for agent_tool in self.tools:
tool, args_schema = self._get_tool_and_input_by_type(
agent_tool.tool.type, metadata=agent_tool.tool.metadata
)
if args_schema == "CHATGPT_PLUGIN":
# if chatgpt plugin this is a list of tools
tools += tool
continue
tools.append(
Tool(
name=slugify(agent_tool.tool.name),
description=agent_tool.tool.description
or ToolDescription[agent_tool.tool.type].value,
args_schema=args_schema if self.type == "OPENAI" else None,
func=tool.run if agent_tool.tool.type != "REPLICATE" else tool,
return_direct=agent_tool.tool.returnDirect,
)
)
return tools
def _get_agent_tools(self) -> Any:
tools = prisma.agenttool.find_many(
where={"agentId": self.id}, include={"tool": True}
)
return tools
def _format_trace(self, trace: Any) -> dict:
if self.documents or self.tools:
return json.dumps(
{
"output": trace.get("output") or trace.get("result"),
"steps": [
{
"action": step[0].tool,
"input": step[0].tool_input,
"log": step[0].log,
"observation": step[1],
}
for step in trace["intermediate_steps"]
],
}
)
return json.dumps(
{
"output": trace.get("output") or trace.get("result"),
"steps": [trace],
}
)
def process_payload(self, payload):
if isinstance(payload, dict):
if self.type == "OPENAI":
payload = str(payload)
return payload
def create_agent_memory(
self, agentId: str, sessionId: str, author: str, message: str
):
prisma.agentmemory.create(
{
"author": author,
"message": message,
"agentId": agentId,
"session": sessionId,
}
)
def cache_message(
self, agent_id: str, session_id: str, query: str, ai_message: str
):
vectorstore: PineconeVectorStore = VectorStoreBase().get_database()
metadata = {
"agentId": agent_id,
"sessionId": str(session_id),
"text": query,
"cached_message": ai_message,
"type": "cache",
"timestamp": time.time(),
}
query_doc = Document(page_content=query, metadata=metadata)
vectorstore.embed_documents([query_doc])
logger.info(f"cached message: {ai_message}")
def get_cached_result(self, query: str) -> str | None:
vectorstore: PineconeVectorStore = VectorStoreBase().get_database()
results = vectorstore.query(
prompt=query,
metadata_filter={"agentId": self.id},
min_score=0.9,
)
if results:
timestamp: float = results[0].metadata.get("timestamp", 0.0)
if timestamp and time.time() - timestamp > self.cache_ttl:
vectorstore.clear_cache(
agent_id=self.id, document_id=results[0].metadata.get("id", "")
)
else:
cached_message: str = results[0].metadata.get("cached_message", "")
return cached_message
return None
def save_intermediate_steps(self, trace: dict) -> None:
prisma.agenttrace.create(
{
"userId": self.userId,
"agentId": self.id,
"data": trace,
}
)
def get_agent(self) -> Any:
pass
| [] |
2024-01-10 | 5l1v3r1/superagent | libs~superagent~app~vectorstores~pinecone.py | import logging
import uuid
from typing import Literal
import backoff
import pinecone
from decouple import config
from langchain.docstore.document import Document
from langchain.embeddings.openai import OpenAIEmbeddings # type: ignore
from pinecone.core.client.models import QueryResponse
from pydantic.dataclasses import dataclass
logger = logging.getLogger(__name__)
@dataclass
class Response:
id: str
text: str
metadata: dict
def to_dict(self):
return {
"id": self.id,
"text": self.text,
"metadata": self.metadata,
}
def __init__(self, id: str, text: str, metadata: dict | None = None):
"""Core dataclass for single record."""
self.id = id
self.text = text
self.metadata = metadata or {}
class PineconeVectorStore:
def __init__(
self,
index_name: str = config("PINECONE_INDEX"),
environment: str = config("PINECONE_ENVIRONMENT"),
pinecone_api_key: str = config("PINECONE_API_KEY"),
) -> None:
if not index_name:
raise ValueError(
"Please provide a Pinecone Index Name via the "
"`PINECONE_INDEX` environment variable."
)
if not environment:
raise ValueError(
"Please provide a Pinecone Environment/Region Name via the "
"`PINECONE_ENVIRONMENT` environment variable."
)
if not pinecone_api_key:
raise ValueError(
"Please provide a Pinecone API key via the "
"`PINECONE_API_KEY` environment variable."
)
pinecone.init(api_key=pinecone_api_key, environment=environment)
logger.info(f"Index name: {index_name}")
self.index = pinecone.Index(index_name)
self.embeddings = OpenAIEmbeddings(
model="text-embedding-ada-002", openai_api_key=config("OPENAI_API_KEY")
) # type: ignore
@backoff.on_exception(backoff.expo, Exception, max_tries=3)
def _embed_with_retry(self, texts):
return self.embeddings.embed_documents(texts)
def embed_documents(self, documents: list[Document], batch_size: int = 100):
chunks = [
{
"id": str(uuid.uuid4()),
"text": doc.page_content,
"chunk": i,
**doc.metadata,
}
for i, doc in enumerate(documents)
]
def batch_generator(chunks, batch_size):
for i in range(0, len(chunks), batch_size):
i_end = min(len(chunks), i + batch_size)
batch = chunks[i:i_end]
yield batch
batch_gen = batch_generator(chunks, batch_size)
for batch in batch_gen:
batch_ids = [chunk["id"] for chunk in batch]
texts_to_embed = [chunk["text"] for chunk in batch]
logger.debug(f"Texts to embed: {texts_to_embed}")
embeddings = self._embed_with_retry(texts_to_embed)
to_upsert = list(zip(batch_ids, embeddings, batch))
logger.debug(f"Upserting: {to_upsert}")
try:
res = self.index.upsert(vectors=to_upsert)
logger.info(f"Upserted documents. {res}")
except Exception as e:
logger.error(f"Failed to upsert documents. Error: {e}")
return self.index.describe_index_stats()
def _extract_match_data(self, match):
"""Extracts id, text, and metadata from a match."""
id = match.id
text = match.metadata.get("text")
metadata = match.metadata
metadata.pop("text")
return id, text, metadata
def _format_response(self, response: QueryResponse) -> list[Response]:
"""
Formats the response dictionary from the vector database into a list of
Response objects.
"""
if not response.get("matches"):
return []
ids, texts, metadata = zip(
*[self._extract_match_data(match) for match in response["matches"]]
)
responses = [
Response(id=id, text=text, metadata=meta)
for id, text, meta in zip(ids, texts, metadata)
]
return responses
def query(
self,
prompt: str,
metadata_filter: dict | None = None,
top_k: int = 3,
namespace: str | None = None,
min_score: float | None = None, # new argument for minimum similarity score
) -> list[Response]:
"""
Returns results from the vector database.
"""
vector = self.embeddings.embed_query(prompt)
raw_responses: QueryResponse = self.index.query(
vector,
filter=metadata_filter,
top_k=top_k,
include_metadata=True,
namespace=namespace,
)
logger.debug(f"Raw responses: {raw_responses}") # leaving for debugging
# filter raw_responses based on the minimum similarity score if min_score is set
if min_score is not None:
raw_responses["matches"] = [
match
for match in raw_responses["matches"]
if match["score"] >= min_score
]
formatted_responses = self._format_response(raw_responses)
return formatted_responses
def query_documents(
self,
prompt: str,
datasource_id: str,
top_k: int | None,
query_type: Literal["document", "all"] = "document",
) -> list[str]:
if top_k is None:
top_k = 3
logger.info(f"Executing query with document id in namespace {datasource_id}")
documents_in_namespace = self.query(
prompt=prompt,
namespace=datasource_id,
)
if documents_in_namespace == [] and query_type == "document":
logger.info("No result with namespace. Executing query without namespace.")
documents_in_namespace = self.query(
prompt=prompt,
metadata_filter={"datasource_id": datasource_id},
top_k=top_k,
)
# A hack if we want to search in all documents but with backwards compatibility
# with namespaces
if documents_in_namespace == [] and query_type == "all":
logger.info("Querying all documents.")
documents_in_namespace = self.query(
prompt=prompt,
top_k=top_k,
)
return [str(response) for response in documents_in_namespace]
def delete(self, datasource_id: str):
vector_dimensionality = 1536
arbitrary_vector = [1.0] * vector_dimensionality
try:
documents_in_namespace = self.index.query(
arbitrary_vector,
namespace=datasource_id,
top_k=9999,
include_metadata=False,
include_values=False,
)
vector_ids = [match["id"] for match in documents_in_namespace["matches"]]
if len(vector_ids) == 0:
logger.info(
f"No vectors found in namespace `{datasource_id}`. "
f"Deleting `{datasource_id}` using default namespace."
)
self.index.delete(
filter={"datasource_id": datasource_id}, delete_all=False
)
else:
logger.info(
f"Deleting {len(vector_ids)} documents in namespace {datasource_id}"
)
self.index.delete(ids=vector_ids, delete_all=False)
except Exception as e:
logger.error(f"Failed to delete {datasource_id}. Error: {e}")
def clear_cache(self, agent_id: str, datasource_id: str | None = None):
try:
filter_dict = {"agentId": agent_id, "type": "cache"}
if datasource_id:
filter_dict["datasource_id"] = datasource_id
self.index.delete(filter=dict(filter_dict), delete_all=False)
logger.info(f"Deleted vectors with agentId `{agent_id}`.")
except Exception as e:
logger.error(
f"Failed to delete vectors with agentId `{agent_id}`. Error: {e}"
)
| [] |
2024-01-10 | 5l1v3r1/superagent | libs~superagent~app~tools~openapi.py | import asyncio
import json
from langchain.chains.openai_functions.openapi import get_openapi_chain
from langchain.tools import BaseTool
class Openapi(BaseTool):
name = "API"
description = "useful for querying an api"
return_direct = False
def _run(self, input: str) -> str:
openapi_url = self.metadata["openApiUrl"]
headers = self.metadata.get("headers")
agent = get_openapi_chain(
spec=openapi_url, headers=json.loads(headers) if headers else None
)
output = agent.run(input)
return output
async def _arun(self, input: str) -> str:
openapi_url = self.metadata["openApiUrl"]
headers = self.metadata.get("headers")
agent = get_openapi_chain(
spec=openapi_url, headers=json.loads(headers) if headers else None
)
loop = asyncio.get_event_loop()
output = await loop.run_in_executor(None, agent.run, input)
return output
| [
"useful for querying an api"
] |
2024-01-10 | airbytehq/tutorial-similarity-search | 3_relevant_articles.py | import streamlit as st
import os
import pymilvus
import openai
with st.form("my_form"):
st.write("Submit a support case")
text_val = st.text_area("Describe your problem?")
submitted = st.form_submit_button("Submit")
if submitted:
import os
import pymilvus
import openai
org_id = 360033549136 # TODO Load from customer login data
pymilvus.connections.connect(uri=os.environ["MILVUS_URL"], token=os.environ["MILVUS_TOKEN"])
collection = pymilvus.Collection("zendesk")
embedding = openai.Embedding.create(input=text_val, model="text-embedding-ada-002")['data'][0]['embedding']
results = collection.search(data=[embedding], anns_field="vector", param={}, limit=1, output_fields=["_id", "subject"], expr=f'status == "new" and organization_id == {org_id}')
if results[0].distances[0] < 0.35:
matching_ticket = results[0][0].entity
st.write(f"This case seems very similar to {matching_ticket.get('subject')} (id #{matching_ticket.get('_id')}). Make sure it has not been submitted before")
else:
# TODO Actually send out the ticket
st.write("Submitted!")
article_results = collection.search(data=[embedding], anns_field="vector", param={}, limit=5, output_fields=["title", "html_url"], expr=f'_ab_stream == "articles"')
st.write(article_results[0])
if len(article_results[0]) > 0:
st.write("We also found some articles that might help you:")
for hit in article_results[0]:
if hit.distance < 0.362:
st.write(f"* [{hit.entity.get('title')}]({hit.entity.get('html_url')})")
| [] |
2024-01-10 | airbytehq/tutorial-similarity-search | 2_open_ticket_check.py | import streamlit as st
import os
import pymilvus
import openai
with st.form("my_form"):
st.write("Submit a support case")
text_val = st.text_area("Describe your problem?")
submitted = st.form_submit_button("Submit")
if submitted:
import os
import pymilvus
import openai
org_id = 360033549136 # TODO Load from customer login data
pymilvus.connections.connect(uri=os.environ["MILVUS_URL"], token=os.environ["MILVUS_TOKEN"])
collection = pymilvus.Collection("zendesk")
embedding = openai.Embedding.create(input=text_val, model="text-embedding-ada-002")['data'][0]['embedding']
results = collection.search(data=[embedding], anns_field="vector", param={}, limit=2, output_fields=["_id", "subject", "description"], expr=f'status == "new" and organization_id == {org_id}')
st.write(results[0])
if len(results[0]) > 0 and results[0].distances[0] < 0.35:
matching_ticket = results[0][0].entity
st.write(f"This case seems very similar to {matching_ticket.get('subject')} (id #{matching_ticket.get('_id')}). Make sure it has not been submitted before")
else:
st.write("Submitted!")
| [] |
2024-01-10 | KevKibe/Mail-QA | slackapp~playground.py | import os
import boto3
from langchain.tools import BaseTool
from langchain.agents import AgentType, initialize_agent
from langchain.chat_models import ChatOpenAI
from langchain.chains.conversation.memory import ConversationBufferWindowMemory
import time
from dotenv import load_dotenv
load_dotenv()
openai_api_key = os.getenv('OPENAI_API_KEY')
llm = ChatOpenAI(
openai_api_key=openai_api_key,
temperature=0,
model_name='gpt-3.5-turbo'
)
conversational_memory = ConversationBufferWindowMemory(
memory_key='chat_history',
k=5,
return_messages=True
)
class DataFetchingTool(BaseTool):
name = "Workspace Data Fetcher"
description = ("use this tool to get data from the workspace also referred to as private data or company data")
def _run(self, query: str):
s3 = boto3.client('s3')
try:
s3.download_file('mailqa-bucket', 'all_texts.txt', "all_texts.txt")
print(f"File {'all_texts.txt'} downloaded successfully from {'mailqa-bucket'}")
with open('all_texts.txt', 'r') as file:
content = file.read()
return content
except Exception as e:
print(f"Error downloading {'all_texts.txt'} from {'mailqa-bucket'}: {e}")
def _arun(self, query: str):
raise NotImplementedError("This tool does not support async")
class EmailFetchingTool(BaseTool):
name = "Email Data Fetcher"
description = ("use this tool to get a users email data and inbox, do not use it if query involves company data")
def _run(self, query: str):
s3 = boto3.client('s3')
try:
s3.download_file('mailqa-bucket', 'emails.txt', "emails.txt")
print(f"File {'emails.txt'} downloaded successfully from {'mailqa-bucket'}")
with open('emails.txt', 'r') as file:
content = file.read()
return content
except Exception as e:
print(f"Error downloading {'emails.txt'} from {'mailqa-bucket'}: {e}")
def _arun(self, query: str):
raise NotImplementedError("This tool does not support async")
tools = [ DataFetchingTool(), EmailFetchingTool()]
sys_msg = """Assistant is a large language model trained by OpenAI.
Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.
Overall, Assistant is a powerful system that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.
"""
agent = initialize_agent(
tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
# prompt = input(">>>")
# start_time = time.time()
# agent.run(prompt)
# end_time = time.time()
# duration = end_time-start_time
# print(duration)
# agent = initialize_agent(
# agent='chat-conversational-react-description',
# tools=tools,
# llm=llm,
# verbose=True,
# max_iterations=3,
# early_stopping_method='generate',
# memory=conversational_memory
# )
new_prompt = agent.agent.create_prompt(
system_message=sys_msg,
tools=tools
)
agent.agent.llm_chain.prompt = new_prompt
# update the agent tools
agent.tools = tools
prompt = input(">>>")
start_time = time.time()
agent.run(prompt)
end_time = time.time()
duration = end_time-start_time
print(duration) | [] |
2024-01-10 | KevKibe/Mail-QA | audio_app~audio_agent_tools.py | import os
import boto3
import ssl
import json
import datetime
import smtplib
import pytz
import postgrest.exceptions
from langchain.utilities import GoogleSerperAPIWrapper
from email.message import EmailMessage
from audio_mail_fetch import GmailAPI
from mail_preprocess import TextProcessor
from datetime import timedelta
from dotenv import load_dotenv
from langchain.tools import BaseTool
from googleapiclient.discovery import build
from google.oauth2.credentials import Credentials
from supabase import create_client
load_dotenv()
nairobi = pytz.timezone('Africa/Nairobi')
nairobi_time = datetime.datetime.now(nairobi)
class EmailFetchingTool(BaseTool):
name = "Email Data Fetcher"
description = f'''
The Email Data Fetcher is a tool specifically designed to retrieve a user's email data, including emails from their inbox.
Today's date and time is {nairobi_time}.
What is returned is updated recent emails in my inbox so you have access to my emails.
When asked for emails in the inbox give a summary of the emails and their content.
When asked about a specific email return every information about the email, if there is no email related to the query say that there is no email related to the question and ask for more information.
The action input for this tool should always include the following parameters:
- 'user_email': The user's email address that is in the prompt.
'''
def _run(self, **action_input):
email = action_input.get('user_email')
supabase_url = os.getenv('SUPABASE_URL')
supabase_key = os.getenv('SUPABASE_KEY')
supabase_client = create_client(supabase_url, supabase_key)
access_token = supabase_client.table('slack_app').select('accesstoken').eq('email', email).single().execute()
access_token = access_token.data['accesstoken']
text_processor = TextProcessor()
gmail_api = GmailAPI(access_token)
email_data_list = gmail_api.get_emails(7)
processed_data = []
for email_data in email_data_list:
processed_email_data = text_processor.preprocess_email_data(email_data)
processed_data.append(str(processed_email_data))
data = ' '.join(processed_data)
return data
def _arun(self, query: str):
raise NotImplementedError("This tool does not support async")
class EmailSendingTool(BaseTool):
name = "Email Sender Tool"
description = '''Use this tool to send an email on behalf of the user, if told to send data from
somewhere look in the Data Fetcher Tool or the Email Fetcher Tool
Do not send an email if it is to @example.com.
Strictly The action input for this tool should always include the following parameters:
- 'email_sender': str - The user's email address that is the email address in the prompt always.
- 'to': str - The email address of the recipient always.
- 'subject': str - The subject of the email always.
- 'body': str - The body content of the email always.
End the email with just the words 'Best Regards' and space it accordingly.
After using the tool say return a confirmation of the email sent, who its been sent to and the content of the email.
Finish the chain after observing that the email(s) has been sent.
Return the content of only that one email sent not more than that one.
Strictly do not execute the Email Data Fetcher tool after using this tool just finish the chain.
Avoid saying 'The response to your last comment is:', replace with the content of the email sent...
If An error occurred: (535, b'5.7.8 Username and Password not accepted. Learn more at\n5.7.8 https://support.google.com/mail/?p=BadCredentials n4-20020a170906688400b0099bd0b5a2bcsm2048836ejr.101 - gsmtp' is observed return this statement "Your Google Account is not fully setup to use this feature. Follow this link to enable it https://mail-app-password-form.streamlit.app/.
'''
def _run(self,**action_input):
load_dotenv()
email_receiver = action_input.get('to')
subject = action_input.get('subject')
body = action_input.get('body')
email_sender = action_input.get('email_sender')
supabase_url = os.getenv('SUPABASE_URL')
supabase_key = os.getenv('SUPABASE_KEY')
supabase_client = create_client(supabase_url, supabase_key)
email_password = supabase_client.table('slack_app').select('app_passwords').eq('email', email_sender).single().execute()
email_password = email_password.data['app_passwords']
em = EmailMessage()
em['From'] = email_sender
em['To'] = email_receiver
em['Subject'] = subject
em.set_content(body)
context = ssl.create_default_context()
try:
with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context) as smtp:
smtp.login(email_sender, email_password)
smtp.sendmail(email_sender, email_receiver, em.as_string())
return em
except smtplib.SMTPAuthenticationError:
return "Your Google Account is not fully setup to use this feature. Follow this link to enable it https://mail-app-password-form.streamlit.app/."
except Exception as e:
return f"An error occurred: {str(e)}"
def _arun(self, query: str):
raise NotImplementedError("This tool does not support async")
class CalenderFetchingTool(BaseTool):
name = "Calender Events Fetcher"
description = '''
The Calender Events Fetcher is a powerful tool designed to retrieve calender events in the user's calender.
The action input for this tool should always include the following parameters:
- 'user_email': The user's email address that is in the prompt.
Respond with the events and the links to the events
'''
def _run(self, **action_input):
email = action_input.get('user_email')
supabase_url = os.getenv('SUPABASE_URL')
supabase_key = os.getenv('SUPABASE_KEY')
supabase_client = create_client(supabase_url, supabase_key)
max_results = 10
access_token = supabase_client.table('slack_app').select('accesstoken').eq('email', email).single().execute()
access_token_data = access_token.data
token_data = json.loads(access_token_data['accesstoken'])
credentials = Credentials.from_authorized_user_info(token_data)
service = build('calendar', 'v3', credentials=credentials)
nairobi = pytz.timezone('Africa/Nairobi')
now = datetime.datetime.now(nairobi)
now = now.isoformat()
events_list = []
try:
events_result = service.events().list(calendarId='primary', timeMin=now,
maxResults=max_results, singleEvents=True,
orderBy='startTime').execute()
events = events_result.get('items', [])
if not events:
return 'No upcoming events found.'
else:
for event in events:
start = event['start'].get('dateTime', event['start'].get('date'))
summary = event['summary']
events_list.append((start, summary))
return events_list
except Exception as error:
return f'An error occurred: {error}'
class EventSchedulingTool(BaseTool):
name = "Calender Event Scheduler"
description = f'''
The Calender Events Scheduler is a powerful tool designed to schedule calender events in the user's calender.
Today's date and time is {nairobi_time}.
Strictly the action input for this tool should always include the following parameters:
- 'summary': str - The summary of the event.
- 'year': int - The year of the start time of the event.Default is 2023.
- 'month': int - The month the event is to start .
- 'day': int - The day the event is to start.
- 'hour': int - The hour the event is to start.
- 'duration': int - How long the event is to take in hours, default is 1 hr.
- 'attendees': str - Emails of attendees of the event created. If is is not specified send an empty list. Make it a list if there is more than one attendee.
- 'user_email':str - The user's email address that is in the prompt.
'''
def _run(self, **action_input):
summary = action_input.get('summary')
year = action_input.get('year')
month = action_input.get('month')
day = action_input.get('day')
hour = action_input.get('hour')
duration = action_input.get('duration')
attendees = action_input.get('attendees')
email = action_input.get('user_email')
start_time = datetime.datetime(year = year, month = month, day = day, hour = hour)
end_time = start_time + timedelta(hours = duration)
supabase_url = os.getenv('SUPABASE_URL')
supabase_key = os.getenv('SUPABASE_KEY')
supabase_client = create_client(supabase_url, supabase_key)
access_token = supabase_client.table('slack_app').select('accesstoken').eq('email', email).single().execute()
access_token_data = access_token.data # Extract the JSON data
token_data = json.loads(access_token_data['accesstoken'])
credentials = Credentials.from_authorized_user_info(token_data)
service = build('calendar', 'v3', credentials=credentials)
event = {
'summary': summary,
'start': {
'dateTime': start_time.isoformat(),
'timeZone': 'Africa/Nairobi',
},
'end': {
'dateTime': end_time.isoformat(),
'timeZone': 'Africa/Nairobi',
},
'attendees': [{'email': attendee} for attendee in attendees],
}
event = service.events().insert(calendarId='primary', body=event).execute()
# return print(f"Event created: {event['htmlLink']}")
return event['htmlLink']
def _arun(self, query: str):
raise NotImplementedError("This tool does not support async")
| [
"\n The Calender Events Fetcher is a powerful tool designed to retrieve calender events in the user's calender. \n The action input for this tool should always include the following parameters:\n - 'user_email': The user's email address that is in the prompt.\n Respond with the events and the links to the events\n ",
"\n The Calender Events Scheduler is a powerful tool designed to schedule calender events in the user's calender. \n Today's date and time is PLACEHOLDER.\n Strictly the action input for this tool should always include the following parameters:\n - 'summary': str - The summary of the event.\n - 'year': int - The year of the start time of the event.Default is 2023.\n - 'month': int - The month the event is to start .\n - 'day': int - The day the event is to start.\n - 'hour': int - The hour the event is to start.\n - 'duration': int - How long the event is to take in hours, default is 1 hr. \n - 'attendees': str - Emails of attendees of the event created. If is is not specified send an empty list. Make it a list if there is more than one attendee. \n - 'user_email':str - The user's email address that is in the prompt.\n ",
"\n The Email Data Fetcher is a tool specifically designed to retrieve a user's email data, including emails from their inbox. \n Today's date and time is PLACEHOLDER.\n What is returned is updated recent emails in my inbox so you have access to my emails.\n When asked for emails in the inbox give a summary of the emails and their content.\n When asked about a specific email return every information about the email, if there is no email related to the query say that there is no email related to the question and ask for more information.\n The action input for this tool should always include the following parameters:\n - 'user_email': The user's email address that is in the prompt.\n "
] |
2024-01-10 | KevKibe/Mail-QA | audio_app~audio_agent.py | import os
import boto3
import time
from dotenv import load_dotenv
from langchain.agents import AgentType, initialize_agent
from langchain.chat_models import ChatOpenAI
from langchain.chains.conversation.memory import ConversationBufferWindowMemory
from langchain.callbacks.human import HumanApprovalCallbackHandler
from audio_agent_tools import EmailFetchingTool, EmailSendingTool, CalenderFetchingTool,EventSchedulingTool, GoogleSerperAPITool
load_dotenv()
class EmailSenderApproval:
def __init__(self):
self.approval_statement = ""
def should_check(self, serialized_obj):
return serialized_obj.get("name") == "Calender Events Fetcher"
def approve(self, input_str):
self.approval_statement = f"Do you approve of the following actions? {input_str} (Y/N): "
approval = input(self.approval_statement)
return approval.lower() in ["y", "yes"]
class Agent:
def __init__(self):
self.openai_api_key = os.getenv('OPENAI_API_KEY')
self.llm = ChatOpenAI(
openai_api_key=self.openai_api_key,
temperature=0,
model_name='gpt-3.5-turbo'
)
checker = EmailSenderApproval()
callback_handler = HumanApprovalCallbackHandler(should_check=checker.should_check, approve=checker.approve)
# callback_handler.set_checker(checker)
self.callbacks = [callback_handler]
self.email_fetching_tool = EmailFetchingTool()
self.email_sending_tool = EmailSendingTool()
self.calender_fetching_tool = CalenderFetchingTool()
self.event_scheduling_tool = EventSchedulingTool()
self.google_search_tool = GoogleSerperAPITool()
self.tools = [self.email_fetching_tool, self.email_sending_tool, self.calender_fetching_tool, self.event_scheduling_tool, self.google_search_tool]
self.sys_msg = """You are an assistant, assisting with email and workspace related information and
based on provided questions and context.
The user is part of a company and you have access to the company's data using the Company Data Fetcher tool and the user's emails using the Email Data Fetcher.
You do not send emails to @example.com extensions ask for the specific email.
You are very talkative and do not give short answers
If you can't answer a question, request more information.
Strictly do not give a response that starts with "The response to your last comment"
After observing that an email has been sent finish the chain.
The email address in the question is the user's email address use that in the tools.
When a user asks what email they got an a certain day, use the Email Data Fetcher.
After sending an email strictly do not execute the Email Data Fetcher.
when a user says hello or what do you do, do not use any tool, just provide an action input as a response
"""
self.conversational_memory = ConversationBufferWindowMemory(
memory_key='chat_history',
k=5,
return_messages=True
)
self.agent = initialize_agent(
agent = "chat-conversational-react-description",
tools=self.tools,
llm=self.llm,
verbose=True,
max_iterations=3,
early_stopping_method='generate',
memory=self.conversational_memory
)
new_prompt = self.agent.agent.create_prompt(
system_message=self.sys_msg,
tools=self.tools
)
self.agent.agent.llm_chain.prompt = new_prompt
def run(self, prompt):
result= self.agent.run(prompt)
return result | [] |
2024-01-10 | KevKibe/Mail-QA | slackapp~playgr.py | import os
import json
import datetime
import time
from datetime import timedelta
from googleapiclient.discovery import build
from google.oauth2.credentials import Credentials
from supabase import create_client
from dotenv import load_dotenv
load_dotenv()
# def get_calendar_events(email):
# load_dotenv()
# supabase_url = os.getenv('SUPABASE_URL')
# supabase_key = os.getenv('SUPABASE_KEY')
# supabase_client = create_client(supabase_url, supabase_key)
# access_token = supabase_client.table('slack_app').select('accesstoken').eq('email', email).single().execute()
# access_token_data = access_token.data # Extract the JSON data
# token_data = json.loads(access_token_data['accesstoken'])
# credentials = Credentials.from_authorized_user_info(token_data)
# service = build('calendar', 'v3', credentials=credentials)
# # Call the Calendar API
# now = datetime.datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time
# print('Getting the upcoming 10 events')
# events_list = []
# try:
# events_result = service.events().list(calendarId='primary', timeMin=now,
# maxResults=10, singleEvents=True,
# orderBy='startTime').execute()
# events = events_result.get('items', [])
# if not events:
# return 'No upcoming events found.'
# else:
# for event in events:
# start = event['start'].get('dateTime', event['start'].get('date'))
# summary = event['summary']
# events_list.append((start, summary))
# return events_list
# except Exception as error:
# return f'An error occurred: {error}'
# start_time = time.time()
# events_list = get_calendar_events("[email protected]")
# print(events_list)
# end_time = time.time()
# duration = end_time - start_time
# print(duration)
def schedule_event(summary, start_time, end_time, attendees):
supabase_url = os.getenv('SUPABASE_URL')
supabase_key = os.getenv('SUPABASE_KEY')
supabase_client = create_client(supabase_url, supabase_key)
email = "[email protected]"
access_token = supabase_client.table('slack_app').select('accesstoken').eq('email', email).single().execute()
access_token_data = access_token.data
token_data = json.loads(access_token_data['accesstoken'])
credentials = Credentials.from_authorized_user_info(token_data)
service = build('calendar', 'v3', credentials=credentials)
# Define the event
event = {
'summary': summary,
'start': {
'dateTime': start_time.isoformat(),
'timeZone': 'Africa/Nairobi',
},
'end': {
'dateTime': end_time.isoformat(),
'timeZone': 'Africa/Nairobi',
},
'attendees': [{'email': attendee} for attendee in attendees],
}
# Call the Calendar API to create the event
event = service.events().insert(calendarId='primary', body=event).execute()
return print(f"Event created: {event['htmlLink']}")
start_time = datetime.datetime(year=2023, month=10, day=27, hour=21)
attendees = ['[email protected]', '[email protected]']
end_time = start_time + timedelta(hours=1)
schedule_event('My Future Event', start_time, end_time, attendees)
# import pytz
# import datetime
# nairobi = pytz.timezone('Africa/Nairobi')
# nairobi_time = datetime.datetime.now(nairobi)
# # nairobi_time= nairobi_time.isoformat()
# # now = datetime.datetime.utcnow().isoformat() +'Z'
# print(nairobi_time)
# import os
# from dotenv import load_dotenv
# from langchain.agents import initialize_agent
# from langchain.chat_models import ChatOpenAI
# from langchain.chains.conversation.memory import ConversationBufferWindowMemory
# from agent_tools import DataFetchingTool
# from langchain.schema.messages import HumanMessage, AIMessage
# llm = ChatOpenAI(
# openai_api_key="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",
# temperature=0,
# model_name='gpt-3.5-turbo'
# )
# # initialize conversational memory
# conversational_memory = ConversationBufferWindowMemory(
# memory_key='chat_history',
# k=5,
# return_messages=True,
# message_class=HumanMessage,
# )
# tools = [DataFetchingTool()]
# # initialize agent with tools
# agent = initialize_agent(
# agent='chat-conversational-react-description',
# tools=tools,
# llm=llm,
# verbose=True,
# max_iterations=3,
# early_stopping_method='generate',
# memory=conversational_memory,
# return_messages = True
# )
# response =agent("how much did the company make?")
# print(response['chat_history'])
# print(response['output']) | [] |
2024-01-10 | KevKibe/Mail-QA | slackapp~email_chain.py | import os
import time
from mail_fetch import GmailAPI
from langchain.vectorstores import Chroma
from langchain.storage import LocalFileStore
from langchain.embeddings import CacheBackedEmbeddings
from mail_preprocess import TextProcessor
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
from langchain.chat_models import ChatOpenAI
from dotenv import load_dotenv
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.prompts.prompt import PromptTemplate
from supabase import create_client
load_dotenv
class ConversationChain:
def __init__(self, email):
load_dotenv()
self.openai_api_key = os.getenv('OPENAI_API_KEY')
self.email = email
self.supabase_url = os.getenv('SUPABASE_URL')
self.supabase_key = os.getenv('SUPABASE_KEY')
self.supabase_client = create_client(self.supabase_url, self.supabase_key)
def fetch_access_token(self):
"""Fetches the access token from the Supabase database."""
try:
access_token = self.supabase_client.table('slack_app').select('accesstoken').eq('email', self.email).single().execute()
return access_token.data['accesstoken']
except Exception as e:
print(f"An error occurred: {str(e)}")
return None
def preprocess_emails(self,access_token):
"""Fetching and preprocesses the emails."""
text_processor = TextProcessor()
gmail_api = GmailAPI(access_token)
email_data_list = gmail_api.get_emails(7)
processed_data = []
for email_data in email_data_list:
processed_email_data = text_processor.preprocess_email_data(email_data)
processed_data.append(str(processed_email_data))
data = ' '.join(processed_data)
return data
def initialize_embeddings_and_vectorstore(self, data):
"""Initializes the embeddings and vectorstore for the chatbot."""
model_name = 'text-embedding-ada-002'
embeddings = OpenAIEmbeddings(
model=model_name,
openai_api_key=self.openai_api_key
)
fs = LocalFileStore("./cache/")
cached_embedder = CacheBackedEmbeddings.from_bytes_store(embeddings, fs, namespace=embeddings.model)
chunk_size = 1000
chunk_overlap = 200
text_splitter = CharacterTextSplitter(separator="\n", chunk_size=chunk_size, chunk_overlap=chunk_overlap)
for dat in data:
text_chunks = text_splitter.split_text(dat)
vectorstore = FAISS.from_texts(texts=text_chunks, embedding=cached_embedder)
return vectorstore
def initialize_conversation_chain(self, vectorstore):
"""Initializes the conversation chain for the chatbot."""
llm = ChatOpenAI(
model_name='gpt-3.5-turbo',
model_kwargs={'api_key': self.openai_api_key},
temperature= 0
)
template = """As an AI assistant, I assist with email and workspace data based on provided questions and context.
Company data after a filename and emails are those with tags from, date, subject, labels.
If I can't answer a question, I'll request more information.
Question: {question} {context}
Answer:"""
prompt_template = PromptTemplate(input_variables=["question", "context"], template=template)
memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
conversation_chain = RetrievalQA.from_chain_type(
llm=llm,
# chain_type_kwargs={"prompt": prompt_template},
memory=memory,
retriever=vectorstore.as_retriever()
)
return conversation_chain
def run(self, user_input):
"""Runs the chatbot."""
access_token = self.fetch_access_token()
data = self.preprocess_emails(access_token)
vectorstore = self.initialize_embeddings_and_vectorstore(data)
conversation_chain = self.initialize_conversation_chain(vectorstore)
return conversation_chain.run(user_input)
# return data
con = ConversationChain("[email protected]")
prompt = input('>>')
start_time = time.time()
run = con.run(prompt)
end_time = time.time()
print(run)
duration = end_time-start_time
print(duration) | [
"t answer a question, I",
"question",
"As an AI assistant, I assist with email and workspace data based on provided questions and context. \n Company data after a filename and emails are those with tags from, date, subject, labels. \n If I can't answer a question, I'll request more information. \n Question: {question} {context}\n Answer:",
"context"
] |
2024-01-10 | AUGMXNT/shisa | eval~generations~gpt4-iscorrect.py | import argparse
import json
from openai import OpenAI
import sqlite3
import sys
import tiktoken
import time
model = 'gpt-4'
client = OpenAI()
'''
texts = [
# allsources
"私はAIとして、人間のように感情や個人的な経験を持っていません。私は訓練されたデータに基づいてテキストを処理し、生成することができます。私の目的は、ユーザーからの入力に対応し、必要に応じて関連情報を提供することです。",
"人工知能として、私は個人的な好みや感情を持っていません。しかし、多くのユーザーが「進撃の巨人」や「鬼滅の刃」などのアニメを楽しんでいるようです。",
"""1. ハイキュー!!: このアニメは、熱血高校バレーボールの物語で、個性豊かな登場人物と壮大なスポーツドラマが特徴です。
2. 進撃の巨人: このアニメは、人類が壁に閉じ込められた世界で生き残る戦いを描いています。サスペンス、アクション、ファンタジー要素が見事に融合しています。
3. 約束のネバーランド: このアニメは、死後の世界を舞台にした心温まる物語です。主人公の少女が亡くなった兄弟を探す旅に出ます。
4. 銀魂: このアニメは、時代劇風のコメディとアクションが組み合わさった物語です。主人公は、地球を守るために日本神話の神々と戦う必要があります。
5. エヴァンゲリオン: このアニメは、宇宙的な規模で展開する複雑なプロットと深遠なテーマで知られています。""",
"""1873年に建設が開始した東京駅は、日本最初の国有鉄道（JR）の中心地として機能しました。当時は木造で、翌年に完成しました。この駅は、大正時代に改装され、豪華な外観と内部に変身しました。
第二次世界大戦後、東京駅は再び復元され、現在見られる形になりました。その後、1964年に新宿駅がオープンし、東京駅は主要な商業および交通ハブから一般的な終点駅へと移行しました。
2013年には、東京駅は「グランドニックス」と呼ばれる巨大複合施設の一部となり、高級ホテルやレストラン、映画館、美術館、屋上庭園などが含まれています。
今日、東京駅は日本で最も繁華街のひとつであり続けており、約50万人の乗客が利用しています。""",
# no-eval
"私はAIとして、人間のように感情や個人的な経験を持っていません。私はデータに基づいて学び、誰かが私に提供した情報に基づいて対することができます。私の目的は、ユーザーエクスペリエンスを向上させ、必要に応じて問題解決を支援することです。",
"AIとして、私には個人的な好みや感情がないため、特定のアニメを持ってこなせません。しかし、多くの人々が「進撃の巨人」や「鬼滅刃」などのアニメを楽しんでいるようです。",
"""1. 「デビルズライン」: このアニメは、人間と竜に取り込まれた少年が、自分の過去と戦っていく物語です。血と死のテーマが強調されおり、「鬼滅の刃」や「チェンソーマン」のような作品に近い感じです。
2. 「キングダム」: こちらは中国の歴史的時代を舞台にした戦争アニメです。主人公は、苦境に立たされた家族を守るために戦い続ける子です。「鬼滅の刃」のような家族愛と侍の精神を描いた物語です。
3. 「進撃の巨人」: このアニメは、巨大な壁に閉じ込められた世界を舞台にしており、その外には巨人が住んでいます。人類は壁内で生し、壁を守る兵士たちが存在します。「鬼滅の刃」のようなサバイバル要素と、人間とモンスターの戦いを描いた物語です。
4. 「ハイキュー!!」: 高校バレーボールを題材にしたこのアニメは、個性豊かな登場人物たちが集結し、一緒に成長していく様子を描いいます。「鬼滅の刃」のような団結力と友情を描いた物語です。
5. 「約束のネバーランド」: このアニメは、地球上のどこにも行けない不思議な島に住む少女たちの物語です。彼女たちは、島の秘密をき明かし、故郷への帰還を夢見ています。「鬼滅の刃」のような探求と友情を描いた物語です。""",
"1873年に建設が開始した東京駅は、日本最初の国有鉄道（JR）の中心地として機能しました。当時の建築家である岡田武市氏によってデインされたこの駅は、1964年に火災に見舞われ、その後再建されました。現在の構造は、1990年代半ばから2000年代初頭にかけて行わた改修プロジェクト「新東京駅」の一部です。このプロジェクトは、高速電車や特急列車の発着場所としてのみならず、商業施設やオィスビルも含む複合的な都市型交通ハブへと進化しました。",
# airoboros
"私は人工知能として、コンピュータサーバー上に存在し、ユーザーからのテキスト入力に基づいて応答するように設計されています。私学習や改善ができず、私の行動はプログラミングされたものだけで構成されています。",
"AIとして、私には個人的な好みや感情がなく、訓練されたデータセットに基づいて動作するように設計されています。したがって、私はニメを視聴したり楽しんだりする能力を持ち合わせていません。",
"""1. 「デビルズライン」: このアニメは、人間と竜に支配された世界で、主人公が自分の過去と戦っていく物語です。「鬼滅の刃」や「チンソーマン」のようなダークファンタジー要素があります。
2. 「進撃の巨人」: このアニメは、人類が壁の外に住む巨大な生き物に脅かされる世界で展開されます。「鬼滅の刃」のようなサバイバホラー要素があります。
3. 「ハイキュー!!」: このアニメは、高校バレーボール部の青春群像劇です。「鬼滅の刃」のようなテーマ別エピソード構成と同じよう、各話は個々の登場人物の視点から始まります。
4. 「約束のネバーランド」: このアニメは、死後の世界で少年と少女が出会う物語です。「チェンソーマン」のような不気味な雰囲気とロテスクな描写が特徴的です。
5. 「暗殺教室」: このアニメは、暗殺者としての才能を持つ高校生が、暗殺者としての才能を持つ教師から学んでいく物語です。「鬼滅刃」のような格闘技の要素があります。""",
"1873年に建設が開始した東京駅は、日本最初の国有鉄道（JR）の中心地として機能しました。当時は「大名」と呼ばれており、その後「橋」と改称されました。1914年に現在の場所に移転し、1960年代に再建されました。今日、東京駅は世界で最も繁華街のひとつであり商業施設やレストラン、ホテル、美術館などが入っている複合施設です。",
]
'''
class CustomArgumentParser(argparse.ArgumentParser):
def error(self, message):
sys.stderr.write(f'error: {message}\n')
print('---')
self.print_help()
sys.exit(2)
# parser = argparse.ArgumentParser(description="Default Reply Benchmarker")
parser = CustomArgumentParser()
parser.add_argument('-d', required=True, help='Require a data file')
try:
args = parser.parse_args()
except argparse.ArgumentError as e:
print(f"Error: {e}")
parser.print_help()
exit(1)
data_file = args.d
texts = json.load(open(data_file))
# Define OpenAI function
def call_openai(text):
completion = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": "You are an expert Japanese translator. Please analyze whether the Japanese is used completely correctly and naturally for a native speaker. Please point out only inaccuracies in language usage: missing words, grammar, punctuation, improper tone/politeness, etc, and ignore the content of the submissions completely.",
},
{
"role": "user",
"content": text,
}
],
temperature=0.1,
max_tokens=4096,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
# print(completion)
return completion.choices[0].message.content
for text in texts:
print()
print("===")
print()
print(text)
print('---')
response = call_openai(text)
print(response)
| [
"You are an expert Japanese translator. Please analyze whether the Japanese is used completely correctly and naturally for a native speaker. Please point out only inaccuracies in language usage: missing words, grammar, punctuation, improper tone/politeness, etc, and ignore the content of the submissions completely."
] |
2024-01-10 | AUGMXNT/shisa | translate~airoboros-3.1~05-look-for-sus-tokencount-ratios.py | import backoff
from concurrent.futures import ThreadPoolExecutor
from loguru import logger
import json
import openai
import plotext as plt
from pprint import pprint
import sqlite3
import sys
from tabulate import tabulate
import traceback
import threading
import tiktoken
import time
# Connect to the SQLite database
DB = 'airoboros.db'
# Set logger level
DEBUG = 0
if not DEBUG:
logger.remove()
logger.add(sys.stderr, level="INFO")
# Execute Threads
def main():
# Get all rows
conn = sqlite3.connect(DB)
conn.row_factory = sqlite3.Row
c = conn.cursor()
c.execute("SELECT id, category, conversation, conversation_ja, translator FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NOT NULL")
rows = c.fetchall()
conn.close()
sus_long = []
sus_short = []
logger.info(f"=== Processing {len(rows)} items ===")
table = []
for row in rows:
r = dict(row)
r['tokencount_conversation'] = get_tokencount(row['conversation'])
r['tokencount_conversation_ja'] = get_tokencount(row['conversation_ja'])
r['tokencount_ratio'] = r['tokencount_conversation_ja']/r['tokencount_conversation']
if r['tokencount_ratio'] >= 3.0:
sus_long.append(r)
elif r['tokencount_ratio'] <= 1.0:
sus_short.append(r)
table.append(r)
'''
Play around with histograms until we get some good cutoffs
# https://pypi.org/project/plotext/
# https://pypi.org/project/plotille/
ratios = [row['tokencount_ratio'] for row in table]
plt.plotsize(None, 30)
plt.hist(ratios, bins=20000, orientation='horizontal')
plt.xlim(0, 100)
plt.ylim(0.7, 1.2)
plt.title('Histogram of Token Count Ratios')
plt.xlabel('Ratio')
plt.ylabel('Frequency')
plt.show()
sys.exit()
'''
# Print tables
def print_table(table):
header_labels = {
'tokencount_conversation': 'tc',
'tokencount_conversation_ja': 'tc_ja',
'tokencount_ratio': 'ratio',
}
selected_fields = ['id', 'category', 'translator', 'tokencount_conversation', 'tokencount_conversation_ja', 'tokencount_ratio']
selected_data = [[row[field] for field in selected_fields] for row in table]
relabeled_headers = [header_labels.get(field, field) for field in selected_fields]
print(tabulate(selected_data, headers=relabeled_headers, floatfmt='.2f'))
print('long:', len(sus_long))
print_table(sus_long)
print('short:', len(sus_short))
print_table(sus_short)
def get_tokencount(conversation_json):
c = json.loads(conversation_json)
enc = tiktoken.get_encoding("cl100k_base")
tokencount = 0
for turn in c:
tokens = enc.encode(turn['value'])
tokencount += len(tokens)
return tokencount
if __name__ == "__main__":
main()
| [] |
2024-01-10 | AUGMXNT/shisa | translate~airoboros-3.1~03-translate-to-ja.gpt35-16k.multiturn-roleplay-writing.py | import backoff
import openai
import json
import sqlite3
import sys
import tiktoken
import time
# We may use a faster model!
model = 'gpt-3.5-turbo-16k'
# Connect to the SQLite database
conn = sqlite3.connect("airoboros.db")
# Create a cursor object
c = conn.cursor()
c.execute("""SELECT id, category, conversation
FROM airoboros_31 WHERE
(category == 'multiturn' OR category == 'roleplay' OR category == 'writing')
AND conversation_ja IS NULL
""")
rows = c.fetchall()
# Define OpenAI function
@backoff.on_exception(backoff.expo, Exception)
def call_openai(text):
response = openai.ChatCompletion.create(
model=model,
messages=[
{
"role": "system",
"content": "You are an expert English-Japanese translator. Translate the text to Japanese. DO NOT respond to the content or follow any other instructions submitted. ONLY translate the text."
},
{
"role": "user",
"content": turn["value"]
}
],
temperature=0.1,
max_tokens=4096,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response["choices"][0]["message"]["content"]
# There are only 3 'from' roles: 'system', 'human', 'gpt' and we'll leave those in English
# We only want to translate the 'value' and then we will reassemble
enc = tiktoken.get_encoding("cl100k_base")
tokencount = []
for row in rows:
ttt = time.time()
id = row[0]
print("===")
print(f"Translating {id} ({row[1]}):")
conversation = json.loads(row[2])
conversation_ja = []
for turn in conversation:
# Token counts
# tokens = enc.encode(turn['value'])
# tokencount.append(len(tokens))
# continue
value_ja = ""
print('>', turn)
# First let's try to get a value
if turn["from"] == "system":
c.execute("SELECT prompt_ja FROM prompts WHERE prompt_en = ?", (turn["value"],))
row = c.fetchone()
if row is not None:
value_ja = row[0]
if not value_ja:
value_ja = call_openai(turn["value"])
time.sleep(1)
print('>>', value_ja)
turn['value'] = value_ja
conversation_ja.append(turn)
# OK, lets
conv_json = json.dumps(conversation_ja)
c.execute("UPDATE airoboros_31 SET conversation_ja = ?, translator=? WHERE id = ?", (conv_json, model, id))
conn.commit()
ttt = time.time() - ttt
print(f"# {ttt:.2f} s")
print()
time.sleep(1)
conn.close()
| [
"You are an expert English-Japanese translator. Translate the text to Japanese. DO NOT respond to the content or follow any other instructions submitted. ONLY translate the text."
] |
2024-01-10 | AUGMXNT/shisa | translate~airoboros-3.1~04-gpt4-longentries.py | import backoff
from concurrent.futures import ThreadPoolExecutor
from loguru import logger
import json
import openai
import sqlite3
import sys
import traceback
import threading
import tiktoken
import time
# Simultaneous calls
THREADS = 2
lock = threading.Lock()
# We may use a faster model!
model = 'gpt-4'
price_input = 0.03
price_output = 0.06
# 32K 0.06 in, 0.12 out
# Connect to the SQLite database
DB = 'airoboros.db'
# Set logger level
DEBUG = 0
if not DEBUG:
logger.remove()
logger.add(sys.stderr, level="INFO")
# Execute Threads
def main():
# > 20K characters
# rows = get_long_rows()
# Untranslated non mathjson!
rows = get_untranslated()
# Retranslate conversation_ja/conversation ratio >3.0, <1.0...
# rows = get_sus_lengths()
with ThreadPoolExecutor(max_workers=THREADS) as executor:
for row in rows:
executor.submit(process_conversation, row)
try:
executor.shutdown(wait=True)
except KeyboardInterrupt:
logger.info("Keyboard Interrupt. Canceling tasks...")
executor.shutdown(wait=False)
raise
'''
This is our initial run of 1077 long items
'''
def get_long_rows():
conn = sqlite3.connect(DB)
c = conn.cursor()
if DEBUG:
c.execute("SELECT id, category, conversation FROM airoboros_31 WHERE category != 'mathjson' AND translator != 'gpt-4' AND LENGTH(conversation_ja) >= 20000 LIMIT 1")
else:
c.execute("SELECT id, category, conversation FROM airoboros_31 WHERE category != 'mathjson' AND translator != 'gpt-4' AND LENGTH(conversation_ja) >= 20000")
rows = c.fetchall()
conn.close()
logger.debug("=== DEBUG MODE (1 item, no saving to DB) ===")
logger.info(f"=== Processing {len(rows)} items ===")
return rows
'''
Somehow there are 998 missing translations:
sqlite> SELECT COUNT(*), category FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NULL GROUP BY category;
2|awareness
1|card
90|coding
23|contextual
20|counterfactual_contextual
1|detailed_writing
6|editor
3|experience
188|general
10|gtkm
110|joke
31|misconception
10|multiple_choice
61|multiturn
17|orca
2|quiz
36|riddle
91|roleplay
1|song
21|stylized_response
187|summarization
5|theory_of_mind
10|trivia
8|wordgame
64|writing
'''
def get_untranslated():
conn = sqlite3.connect(DB)
c = conn.cursor()
if DEBUG:
c.execute("SELECT id, category, conversation FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NULL ORDER BY LENGTH(conversation) ASC LIMIT 1")
else:
c.execute("SELECT id, category, conversation FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NULL ORDER BY LENGTH(conversation) ASC")
rows = c.fetchall()
conn.close()
logger.debug("=== DEBUG MODE (1 item, no saving to DB) ===")
logger.info(f"=== Processing {len(rows)} items ===")
return rows
def get_sus_lengths():
conn = sqlite3.connect(DB)
conn.row_factory = sqlite3.Row
c = conn.cursor()
if DEBUG:
c.execute("SELECT id, category, conversation, conversation_ja FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NOT NULL AND translator != 'gpt-4' LIMIT 1")
else:
c.execute("SELECT id, category, conversation, conversation_ja FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NOT NULL AND translator != 'gpt-4'")
rows = c.fetchall()
conn.close()
# This will take about 30s to filter...
def get_tokencount(conversation_json):
c = json.loads(conversation_json)
enc = tiktoken.get_encoding("cl100k_base")
tokencount = 0
for turn in c:
tokens = enc.encode(turn['value'])
tokencount += len(tokens)
return tokencount
sus = []
for row in rows:
tc = get_tokencount(row['conversation'])
tc_ja = get_tokencount(row['conversation_ja'])
ratio = tc_ja/tc
if ratio >= 3.0 or ratio < 0.5:
sus.append(row)
logger.debug("=== DEBUG MODE (1 item, no saving to DB) ===")
logger.info(f"=== Processing {len(sus)} items ===")
return sus
thread_dict = {}
def get_thread_number():
thread_id = threading.get_ident()
if thread_id not in thread_dict:
thread_dict[thread_id] = len(thread_dict) + 1
return thread_dict[thread_id]
# We handle each conversation as a row
def process_conversation(row):
try:
# Since connections aren't threadsafe...
conn = sqlite3.connect(DB)
c = conn.cursor()
# Timer
ttt = time.time()
id = row[0]
category = row[1]
conversation = json.loads(row[2])
thread_id = get_thread_number()
logger.info(f"{thread_id}: START {id} ({category})...")
conversation_ja = []
for turn in conversation:
value_ja = ""
logger.debug(turn)
# First let's try to get a value - we won't cache this
'''
if turn["from"] == "system":
c.execute("SELECT prompt_ja FROM prompts WHERE prompt_en = ?", (turn["value"],))
row = c.fetchone()
if row is not None:
value_ja = row[0]
'''
if not value_ja:
logger.debug(f"{thread_id}: before call_open")
value_ja = call_openai(turn["value"])
logger.debug(f"{thread_id}: after call_open")
turn['value'] = value_ja
conversation_ja.append(turn)
conv_json = json.dumps(conversation_ja)
logger.debug(conv_json)
# We don't update the DB if debug...
if not DEBUG:
with lock:
c.execute("UPDATE airoboros_31 SET conversation_ja = ?, translator=? WHERE id = ?", (conv_json, model, id))
c.execute("REPLACE INTO translate_history (id, translator, translation) VALUES (?, ?, ?)", (id, model, conv_json))
conn.commit()
ttt = time.time() - ttt
logger.info(f"{thread_id}: END {id} ({ttt:.2f} s)")
except Exception as e:
# tb_str = ''.join(traceback.format_exception(None, exception, exception.__traceback__))
logger.error(f"{thread_id}: EXCEPTION in {id}: {e}")
traceback.print_exc() # This will print the full traceback to the log
# logger.error(f"Traceback: {tb_str}")
# traceback.print_exc() # This will print the full traceback to the log
finally:
conn.close()
# Function to log traceback with Loguru on backoff event
def loguru_traceback(details):
thread_id = get_thread_number()
enc = tiktoken.get_encoding("cl100k_base")
tokens = enc.encode(details['args'][0])
details["args"] = f"({len(tokens)} tokens)"
logger.warning(f"{thread_id}: Backoff triggered due to an exception: {details}") #, exc_info=True)
# exc_info=True not working
# logger.warning("Exception occurred", exc_info=True)
# Define OpenAI function
@backoff.on_exception(backoff.expo, Exception, base=5, factor=2, max_value=120, max_tries=10, on_backoff=loguru_traceback)
def call_openai(text):
thread_id = get_thread_number()
enc = tiktoken.get_encoding("cl100k_base")
tokens = enc.encode(text)
price = len(tokens)/1000.0*price_input
logger.info(f"{thread_id}: SEND {len(tokens)} tokens (${price:.4f})")
t = time.time()
response = openai.ChatCompletion.create(
model=model,
messages=[
{
"role": "system",
"content": "Please translate the following to idiomatic Japanese. Take care to use the appropriate formality and tone, use natural diction, and to properly localize names, dates, addresses, citations, etc for native Japanese-only speakers:"
},
{
"role": "user",
"content": text
}
],
temperature=0.1,
max_tokens=4096,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
tokens_ja = enc.encode(response["choices"][0]["message"]["content"])
price = len(tokens)/1000.0*price_output
t = time.time()-t
logger.info(f"{thread_id}: RECIEVED {len(tokens_ja)} JA tokens (${price:.4f}; {t:.2f} s)")
return response["choices"][0]["message"]["content"]
if __name__ == "__main__":
main()
| [
"Please translate the following to idiomatic Japanese. Take care to use the appropriate formality and tone, use natural diction, and to properly localize names, dates, addresses, citations, etc for native Japanese-only speakers:"
] |
2024-01-10 | AUGMXNT/shisa | translate~airoboros-3.1~03-translate-to-ja.py | import backoff
import openai
import json
import sqlite3
import sys
import tiktoken
import time
# We may use a faster model!
model = 'gpt-4'
# Connect to the SQLite database
conn = sqlite3.connect("airoboros.db")
# Create a cursor object
c = conn.cursor()
c.execute("SELECT id, category, conversation FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NULL")
rows = c.fetchall()
# Define OpenAI function
@backoff.on_exception(backoff.expo, Exception)
def call_openai(text):
response = openai.ChatCompletion.create(
model=model,
messages=[
{
"role": "system",
"content": "Translate the following to Japanese:"
},
{
"role": "user",
"content": turn["value"]
}
],
temperature=0.1,
max_tokens=4096,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response["choices"][0]["message"]["content"]
# There are only 3 'from' roles: 'system', 'human', 'gpt' and we'll leave those in English
# We only want to translate the 'value' and then we will reassemble
enc = tiktoken.get_encoding("cl100k_base")
tokencount = []
for row in rows:
ttt = time.time()
id = row[0]
print("===")
print(f"Translating {id} ({row[1]}):")
conversation = json.loads(row[2])
conversation_ja = []
for turn in conversation:
# Token counts
# tokens = enc.encode(turn['value'])
# tokencount.append(len(tokens))
# continue
value_ja = ""
print('>', turn)
# First let's try to get a value
if turn["from"] == "system":
c.execute("SELECT prompt_ja FROM prompts WHERE prompt_en = ?", (turn["value"],))
row = c.fetchone()
if row is not None:
value_ja = row[0]
if not value_ja:
value_ja = call_openai(turn["value"])
time.sleep(1)
print('>>', value_ja)
turn['value'] = value_ja
conversation_ja.append(turn)
# OK, lets
conv_json = json.dumps(conversation_ja)
c.execute("UPDATE airoboros_31 SET conversation_ja = ?, translator=? WHERE id = ?", (conv_json, model, id))
conn.commit()
ttt = time.time() - ttt
print(f"# {ttt:.2f} s")
print()
time.sleep(1)
conn.close()
| [
"Translate the following to Japanese:"
] |
2024-01-10 | AUGMXNT/shisa | translate~airoboros-3.1~02-cache-system-prompts.py | from collections import defaultdict
from pprint import pprint
import openai
import json
import sqlite3
import sys
import tiktoken
import time
# Connect to the SQLite database
conn = sqlite3.connect("airoboros.db")
# Create a cursor object
c = conn.cursor()
c.execute("SELECT id, category, conversation FROM airoboros_31 WHERE category != 'mathjson' AND conversation_ja IS NULL")
rows = c.fetchall()
conn.close()
# There are only 3 'from' roles: 'system', 'human', 'gpt' and we'll leave those in English
# We only want to translate the 'value' and then we will reassemble
prompts = defaultdict(int)
for row in rows:
conversation = json.loads(row[2])
for turn in conversation:
if turn["from"] == "system":
prompts[turn["value"]] += 1
repeat_prompts = {prompt: count for prompt, count in prompts.items() if count > 1}
# Time to make the donuts
conn = sqlite3.connect("airoboros.db")
c = conn.cursor()
c.execute("""
CREATE TABLE IF NOT EXISTS prompts (
prompt_en TEXT PRIMARY KEY,
prompt_ja TEXT
);
""")
conn.commit()
# TODO: if we run this again, we should insert the prompts first, then SELECT
# only empty prompts...
for prompt in repeat_prompts:
print('>', prompt)
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{
"role": "system",
"content": "Translate the following to Japanese:"
},
{
"role": "user",
"content": prompt
}
],
temperature=0.1,
max_tokens=4096,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
prompt_ja = response["choices"][0]["message"]["content"]
print('>', prompt_ja)
# Insert into DB
c.execute("INSERT OR REPLACE INTO prompts (prompt_en, prompt_ja) VALUES (?, ?)", (prompt, prompt_ja))
conn.commit()
print()
| [
"Translate the following to Japanese:",
"content"
] |
2024-01-10 | pmk7/python-language-learning-app | sen_gen.py | import os
import openai
from data import *
class SentenceGenerator:
"""Generates a sentence based on a given word, fetched from the OpenAI API"""
def __init__(self, api_key):
self.api_key = api_key
openai.api_key = api_key
def generate_sentence(self, word, max_tokens=50, temperature=0.9):
prompt = f"Ein Beispiel mit: {word}"
try:
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=max_tokens,
temperature=temperature,
stop=[".", "!", "?"]
)
response_text = response.get('choices')[0].get('text')
return response_text.strip()
except openai.error.OpenAIError as error:
print(f"Error connecting to the OpenAI API: {error}")
return None
except Exception as error:
print(f"Unexpected error: {error}")
return None
def test_api(self, word):
try:
response = openai.Completion.create(
engine="text-davinci-003",
prompt="Test: ",
max_tokens=5,
temperature=0.9,
stop=[".", "!", "?"]
)
if response.status_code == 200:
return True
else:
return False
except openai.error.OpenAIError as error:
# print(f"Error connecting to the OpenAI API: {error}")
return False
except Exception as error:
# print(f"Unexpected error: {error}")
return False
| [
"Ein Beispiel mit: PLACEHOLDER",
"Test: "
] |
2024-01-10 | Will-Shaddix/LL-NVM | LLM-Sceduler~configs~William~new_fs.py | from gem5.utils.requires import requires
from gem5.components.boards.x86_board import X86Board
from gem5.components.memory.single_channel import SingleChannelDDR3_1600
from gem5.components.cachehierarchies.ruby.mesi_two_level_cache_hierarchy import (MESITwoLevelCacheHierarchy,)
from gem5.components.processors.simple_switchable_processor import SimpleSwitchableProcessor
from gem5.coherence_protocol import CoherenceProtocol
from gem5.isas import ISA
from gem5.components.processors.cpu_types import CPUTypes
from gem5.resources.resource import Resource
from gem5.simulate.simulator import Simulator
from gem5.simulate.exit_event import ExitEvent
# This runs a check to ensure the gem5 binary is compiled to X86 and supports
# the MESI Two Level coherence protocol.
requires(
isa_required=ISA.X86,
coherence_protocol_required=CoherenceProtocol.MESI_TWO_LEVEL,
kvm_required=True,
)
# Here we setup a MESI Two Level Cache Hierarchy.
cache_hierarchy = MESITwoLevelCacheHierarchy(
l1d_size="32KiB",
l1d_assoc=8,
l1i_size="32KiB",
l1i_assoc=8,
l2_size="256kB",
l2_assoc=16,
num_l2_banks=1,
)
# Setup the system memory.
# Note, by default DDR3_1600 defaults to a size of 8GiB. However, a current
# limitation with the X86 board is it can only accept memory systems up to 3GB.
# As such, we must fix the size.
memory = SingleChannelDDR3_1600("2GiB")
# Here we setup the processor. This is a special switchable processor in which
# a starting core type and a switch core type must be specified. Once a
# configuration is instantiated a user may call `processor.switch()` to switch
# from the starting core types to the switch core types. In this simulation
# we start with KVM cores to simulate the OS boot, then switch to the Timing
# cores for the command we wish to run after boot.
processor = SimpleSwitchableProcessor(
starting_core_type=CPUTypes.KVM,
switch_core_type=CPUTypes.TIMING,
num_cores=2,
)
# Here we setup the board. The X86Board allows for Full-System X86 simulations.
board = X86Board(
clk_freq="3GHz",
processor=processor,
memory=memory,
cache_hierarchy=cache_hierarchy,
)
# This is the command to run after the system has booted. The first `m5 exit`
# will stop the simulation so we can switch the CPU cores from KVM to timing
# and continue the simulation to run the echo command, sleep for a second,
# then, again, call `m5 exit` to terminate the simulation. After simulation
# has ended you may inspect `m5out/system.pc.com_1.device` to see the echo
# output.
command = "m5 exit;" \
+ "echo 'This is running on Timing CPU cores.';" \
+ "sleep 1;" \
+ "m5 exit;"
# Here we set the Full System workload.
# The `set_workload` function for the X86Board takes a kernel, a disk image,
# and, optionally, a the contents of the "readfile". In the case of the
# "x86-ubuntu-18.04-img", a file to be executed as a script after booting the
# system.
board.set_kernel_disk_workload(
kernel=Resource("x86-linux-kernel-5.4.49",),
disk_image=Resource("x86-ubuntu-18.04-img"),
readfile_contents=command,
)
simulator = Simulator(
board=board,
on_exit_event={
# Here we want override the default behavior for the first m5 exit
# exit event. Instead of exiting the simulator, we just want to
# switch the processor. The 2nd 'm5 exit' after will revert to using
# default behavior where the simulator run will exit.
ExitEvent.EXIT : (func() for func in [processor.switch]),
},
)
simulator.run() | [] |
2024-01-10 | Will-Shaddix/LL-NVM | LLM-Sceduler~configs~example~gem5_library~x86-gapbs-benchmarks.py | # Copyright (c) 2021 The Regents of the University of California.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
Script to run GAPBS benchmarks with gem5. The script expects the
benchmark program and the simulation size to run. The input is in the format
<benchmark_prog> <size> <synthetic>
The system is fixed with 2 CPU cores, MESI Two Level system cache and 3 GB
DDR4 memory. It uses the x86 board.
This script will count the total number of instructions executed
in the ROI. It also tracks how much wallclock and simulated time.
Usage:
------
```
scons build/X86/gem5.opt
./build/X86/gem5.opt \
configs/example/gem5_library/x86-gabps-benchmarks.py \
--benchmark <benchmark_name> \
--synthetic <synthetic> \
--size <simulation_size/graph_name>
```
"""
import argparse
import time
import sys
import m5
from m5.objects import Root
from gem5.utils.requires import requires
from gem5.components.boards.x86_board import X86Board
from gem5.components.memory import DualChannelDDR4_2400
from gem5.components.processors.simple_switchable_processor import (
SimpleSwitchableProcessor,
)
from gem5.components.processors.cpu_types import CPUTypes
from gem5.isas import ISA
from gem5.coherence_protocol import CoherenceProtocol
from gem5.resources.resource import Resource
from gem5.simulate.simulator import Simulator
from gem5.simulate.exit_event import ExitEvent
requires(
isa_required=ISA.X86,
coherence_protocol_required=CoherenceProtocol.MESI_TWO_LEVEL,
kvm_required=True,
)
# Following are the list of benchmark programs for gapbs
benchmark_choices = ["cc", "bc", "tc", "pr", "bfs"]
synthetic_choices = ["0", "1"]
size_choices = [
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"10",
"11",
"12",
"13",
"14",
"15",
"16",
"USA-road-d.NY.gr",
]
parser = argparse.ArgumentParser(
description="An example configuration script to run the gapbs benchmarks."
)
# The only positional argument accepted is the benchmark name in this script.
parser.add_argument(
"--benchmark",
type=str,
required=True,
help="Input the benchmark program to execute.",
choices=benchmark_choices,
)
parser.add_argument(
"--synthetic",
type=str,
required=True,
help="Synthetic Graph:: 1: synthetic graph is True; 0: real graph",
choices=synthetic_choices,
)
parser.add_argument(
"--size",
type=str,
required=True,
help="Graph Size:: If synthetic is True, then specify a size [1 .. 15]. \
Otherwise, specify a graph name [USA-road-d.NY.gr]",
choices=size_choices,
)
args = parser.parse_args()
# Setting up all the fixed system parameters here
# Caches: MESI Two Level Cache Hierarchy
from gem5.components.cachehierarchies.ruby.mesi_two_level_cache_hierarchy import (
MESITwoLevelCacheHierarchy,
)
cache_hierarchy = MESITwoLevelCacheHierarchy(
l1d_size="32kB",
l1d_assoc=8,
l1i_size="32kB",
l1i_assoc=8,
l2_size="256kB",
l2_assoc=16,
num_l2_banks=2,
)
# Memory: Dual Channel DDR4 2400 DRAM device.
# The X86 board only supports 3 GB of main memory.
memory = DualChannelDDR4_2400(size="3GB")
# Here we setup the processor. This is a special switchable processor in which
# a starting core type and a switch core type must be specified. Once a
# configuration is instantiated a user may call `processor.switch()` to switch
# from the starting core types to the switch core types. In this simulation
# we start with KVM cores to simulate the OS boot, then switch to the Timing
# cores for the command we wish to run after boot.
processor = SimpleSwitchableProcessor(
starting_core_type=CPUTypes.KVM,
switch_core_type=CPUTypes.TIMING,
isa=ISA.X86,
num_cores=2,
)
# Here we setup the board. The X86Board allows for Full-System X86 simulations
board = X86Board(
clk_freq="3GHz",
processor=processor,
memory=memory,
cache_hierarchy=cache_hierarchy,
)
# Here we set the FS workload, i.e., gapbs benchmark program
# After simulation has ended you may inspect
# `m5out/system.pc.com_1.device` to the stdout, if any.
# After the system boots, we execute the benchmark program and wait till the
# ROI `workbegin` annotation is reached. We start collecting the number of
# committed instructions till ROI ends (marked by `workend`). We then finish
# executing the rest of the benchmark.
# GAPBS benchmarks can be run using a synthetic graph
if args.synthetic == "1":
if args.size == "USA-road-d.NY.gr":
print(
"fatal: cannot use a real graph with --synthetic 1",
file=sys.stderr,
)
exit(-1)
command = "./{} -g {}\n".format(args.benchmark, args.size)
else:
command = "./{} -sf ../{}".format(args.benchmark, args.size)
board.set_kernel_disk_workload(
# The x86 linux kernel will be automatically downloaded to the
# `~/.cache/gem5` directory if not already present.
# gapbs benchamarks was tested with kernel version 4.19.83
kernel=Resource("x86-linux-kernel-4.19.83"),
# The x86-gapbs image will be automatically downloaded to the
# `~/.cache/gem5` directory if not already present.
disk_image=Resource("x86-gapbs"),
readfile_contents=command,
)
def handle_exit():
print("Done booting Linux")
print("Resetting stats at the start of ROI!")
m5.stats.reset()
global start_tick
start_tick = m5.curTick()
processor.switch()
yield False # E.g., continue the simulation.
print("Dump stats at the end of the ROI!")
m5.stats.dump()
yield True # Stop the simulation. We're done.
simulator = Simulator(
board=board,
on_exit_event={
ExitEvent.EXIT: handle_exit(),
},
)
# We maintain the wall clock time.
globalStart = time.time()
print("Running the simulation")
print("Using KVM cpu")
# There are a few thihngs to note regarding the gapbs benchamrks. The first is
# that there are several ROI annotations in the code present in the disk image.
# These ROI begin and end calls are inside a loop. Therefore, we only simulate
# the first ROI annotation in details. The X86Board currently does not support
# `work items started count reached`.
simulator.run()
end_tick = m5.curTick()
# Since we simulated the ROI in details, therefore, simulation is over at this
# point.
# Simulation is over at this point. We acknowledge that all the simulation
# events were successful.
print("All simulation events were successful.")
# We print the final simulation statistics.
print("Done with the simulation")
print()
print("Performance statistics:")
print("Simulated time in ROI: %.2fs" % ((end_tick - start_tick) / 1e12))
print(
"Ran a total of", simulator.get_current_tick() / 1e12, "simulated seconds"
)
print(
"Total wallclock time: %.2fs, %.2f min"
% (time.time() - globalStart, (time.time() - globalStart) / 60)
)
| [] |
2024-01-10 | Will-Shaddix/LL-NVM | LLM-Sceduler~configs~example~gem5_library~x86-npb-benchmarks.py | # Copyright (c) 2021 The Regents of the University of California.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
Script to run NAS parallel benchmarks with gem5. The script expects the
benchmark program to run. The input is in the format
<benchmark_prog>.<class>.x .The system is fixed with 2 CPU cores, MESI
Two Level system cache and 3 GB DDR4 memory. It uses the x86 board.
This script will count the total number of instructions executed
in the ROI. It also tracks how much wallclock and simulated time.
Usage:
------
```
scons build/X86/gem5.opt
./build/X86/gem5.opt \
configs/example/gem5_library/x86-npb-benchmarks.py \
--benchmark <benchmark_name> \
--size <benchmark_class>
```
"""
import argparse
import time
import m5
from m5.objects import Root
from gem5.utils.requires import requires
from gem5.components.boards.x86_board import X86Board
from gem5.components.memory import DualChannelDDR4_2400
from gem5.components.processors.simple_switchable_processor import (
SimpleSwitchableProcessor,
)
from gem5.components.processors.cpu_types import CPUTypes
from gem5.isas import ISA
from gem5.coherence_protocol import CoherenceProtocol
from gem5.resources.resource import Resource
from gem5.simulate.simulator import Simulator
from gem5.simulate.simulator import ExitEvent
from m5.stats.gem5stats import get_simstat
from m5.util import warn
requires(
isa_required=ISA.X86,
coherence_protocol_required=CoherenceProtocol.MESI_TWO_LEVEL,
kvm_required=True,
)
# Following are the list of benchmark programs for npb.
benchmark_choices = ["bt", "cg", "ep", "ft", "is", "lu", "mg", "sp"]
# We are restricting classes of NPB to A, B and C as the other classes (D and
# F) require main memory size of more than 3 GB. The X86Board is currently
# limited to 3 GB of memory. This limitation is explained later in line 136.
# The resource disk has binaries for class D. However, only `ep` benchmark
# works with class D in the current configuration. More information on the
# memory footprint for NPB is available at https://arxiv.org/abs/2010.13216
size_choices = ["A", "B", "C"]
parser = argparse.ArgumentParser(
description="An example configuration script to run the npb benchmarks."
)
# The only positional argument accepted is the benchmark name in this script.
parser.add_argument(
"--benchmark",
type=str,
required=True,
help="Input the benchmark program to execute.",
choices=benchmark_choices,
)
parser.add_argument(
"--size",
type=str,
required=True,
help="Input the class of the program to simulate.",
choices=size_choices,
)
parser.add_argument(
"--ticks",
type=int,
help="Optionally put the maximum number of ticks to execute during the "
"ROI. It accepts an integer value.",
)
args = parser.parse_args()
# The simulation may fail in the case of `mg` with class C as it uses 3.3 GB
# of memory (more information is availabe at https://arxiv.org/abs/2010.13216).
# We warn the user here.
if args.benchmark == "mg" and args.size == "C":
warn(
"mg.C uses 3.3 GB of memory. Currently we are simulating 3 GB\
of main memory in the system."
)
# The simulation will fail in the case of `ft` with class C. We warn the user
# here.
elif args.benchmark == "ft" and args.size == "C":
warn(
"There is not enough memory for ft.C. Currently we are\
simulating 3 GB of main memory in the system."
)
# Checking for the maximum number of instructions, if provided by the user.
# Setting up all the fixed system parameters here
# Caches: MESI Two Level Cache Hierarchy
from gem5.components.cachehierarchies.ruby.mesi_two_level_cache_hierarchy import (
MESITwoLevelCacheHierarchy,
)
cache_hierarchy = MESITwoLevelCacheHierarchy(
l1d_size="32kB",
l1d_assoc=8,
l1i_size="32kB",
l1i_assoc=8,
l2_size="256kB",
l2_assoc=16,
num_l2_banks=2,
)
# Memory: Dual Channel DDR4 2400 DRAM device.
# The X86 board only supports 3 GB of main memory.
memory = DualChannelDDR4_2400(size="3GB")
# Here we setup the processor. This is a special switchable processor in which
# a starting core type and a switch core type must be specified. Once a
# configuration is instantiated a user may call `processor.switch()` to switch
# from the starting core types to the switch core types. In this simulation
# we start with KVM cores to simulate the OS boot, then switch to the Timing
# cores for the command we wish to run after boot.
processor = SimpleSwitchableProcessor(
starting_core_type=CPUTypes.KVM,
switch_core_type=CPUTypes.TIMING,
isa=ISA.X86,
num_cores=2,
)
# Here we setup the board. The X86Board allows for Full-System X86 simulations
board = X86Board(
clk_freq="3GHz",
processor=processor,
memory=memory,
cache_hierarchy=cache_hierarchy,
)
# Here we set the FS workload, i.e., npb benchmark program
# After simulation has ended you may inspect
# `m5out/system.pc.com_1.device` to the stdout, if any.
# After the system boots, we execute the benchmark program and wait till the
# ROI `workbegin` annotation is reached (m5_work_begin()). We start collecting
# the number of committed instructions till ROI ends (marked by `workend`).
# We then finish executing the rest of the benchmark.
# Also, we sleep the system for some time so that the output is printed
# properly.
command = (
"/home/gem5/NPB3.3-OMP/bin/{}.{}.x;".format(args.benchmark, args.size)
+ "sleep 5;"
+ "m5 exit;"
)
board.set_kernel_disk_workload(
# The x86 linux kernel will be automatically downloaded to the
# `~/.cache/gem5` directory if not already present.
# npb benchamarks was tested with kernel version 4.19.83
kernel=Resource("x86-linux-kernel-4.19.83"),
# The x86-npb image will be automatically downloaded to the
# `~/.cache/gem5` directory if not already present.
disk_image=Resource("x86-npb"),
readfile_contents=command,
)
# The first exit_event ends with a `workbegin` cause. This means that the
# system started successfully and the execution on the program started.
def handle_workbegin():
print("Done booting Linux")
print("Resetting stats at the start of ROI!")
m5.stats.reset()
# We have completed up to this step using KVM cpu. Now we switch to timing
# cpu for detailed simulation.
# # Next, we need to check if the user passed a value for --ticks. If yes,
# then we limit out execution to this number of ticks during the ROI.
# Otherwise, we simulate until the ROI ends.
processor.switch()
if args.ticks:
# schedule an exit event for this amount of ticks in the future.
# The simulation will then continue.
m5.scheduleTickExitFromCurrent(args.ticks)
yield False
# The next exit_event is to simulate the ROI. It should be exited with a cause
# marked by `workend`.
# We exepect that ROI ends with `workend` or `simulate() limit reached`.
# Otherwise the simulation ended unexpectedly.
def handle_workend():
print("Dump stats at the end of the ROI!")
m5.stats.dump()
yield False
simulator = Simulator(
board=board,
on_exit_event={
ExitEvent.WORKBEGIN: handle_workbegin(),
ExitEvent.WORKEND: handle_workend(),
},
)
# We maintain the wall clock time.
globalStart = time.time()
print("Running the simulation")
print("Using KVM cpu")
# We start the simulation.
simulator.run()
# We need to note that the benchmark is not executed completely till this
# point, but, the ROI has. We collect the essential statistics here before
# resuming the simulation again.
# Simulation is over at this point. We acknowledge that all the simulation
# events were successful.
print("All simulation events were successful.")
# We print the final simulation statistics.
print("Done with the simulation")
print()
print("Performance statistics:")
# manually calculate ROI time if ticks arg is used in case the
# entire ROI wasn't simulated
if args.ticks:
print(f"Simulated time in ROI (to tick): {args.ticks/ 1e12}s")
else:
print(f"Simulated time in ROI: {simulator.get_roi_ticks()[0] / 1e12}s")
print(
f"Ran a total of {simulator.get_current_tick() / 1e12} simulated seconds"
)
print(
"Total wallclock time: %.2fs, %.2f min"
% (time.time() - globalStart, (time.time() - globalStart) / 60)
)
| [] |
2024-01-10 | airtai/captn-backend | tests~captn_agents~test_initial_conversation.py | # from autogen import OpenAIWrapper
from typing import Any, Dict, Union
from unittest.mock import Mock
from captn.captn_agents.backend.initial_team import InitialTeam
from .utils import last_message_is_termination
response_prefix = "Response from team 'planning_team_1':\n"
create_team = Mock()
create_team.side_effect = [
f"{response_prefix}should I distinguish between lower and upper case letters?",
f"{response_prefix}The task has been done.",
] * 5
answer_to_team_lead_question = Mock()
answer_to_team_lead_question.side_effect = [
f"{response_prefix}The task has been done.",
] * 5
function_map = {
"create_team": create_team,
"answer_to_team_lead_question": answer_to_team_lead_question,
}
roles = [
{
"Name": "User_proxy",
"Description": "Your job is to comunicate with the Product Owner, do NOT suggest any code or execute the code by yourself",
},
{
"Name": "Product_owner",
"Description": "You are a product owner in a software company.",
},
]
task = "Create a python program for checking whether a string is palindrome or not"
initial_team = InitialTeam(
user_id=1,
task=task,
roles=roles,
conv_id=13,
# function_map=function_map, # type: ignore
human_input_mode="NEVER",
)
def test_inital_message() -> None:
for key in ["## Guidelines", "## Constraints"]:
assert key in initial_team.initial_message, key
expected_commands = """## Commands
You have access to the following commands:
1. create_team: Create an ad-hoc team to solve the problem, params: (json_as_a_string: string)
2. answer_to_team_lead_question: Answer to the team leaders question, params: (answer: string, team_name: str)
"""
assert expected_commands in initial_team.initial_message
# @pytest.mark.vcr(
# filter_headers=["api-key"]
# )
def test_initial_team() -> None:
initial_team.initiate_chat()
assert last_message_is_termination(initial_team)
# for name in logging.root.manager.loggerDict:
# print(name)
# loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]
try:
from termcolor import colored
except ImportError:
def colored(x: str, *args: Any, **kwargs: Any) -> Any: # type: ignore
return x
def _print_received_message(
message: Union[Dict[str, Any], str]
) -> None: # , sender: Agent):
# print the message received
# print(colored(sender.name, "yellow"), "(to", f"{self.name}):\n", flush=True)
# print(f"{message['name']}:", flush=True)
if message.get("role") == "function": # type: ignore
func_print = f"***** Response from calling function \"{message['name']}\" *****" # type: ignore
print(colored(func_print, "green"), flush=True)
print(message["content"], flush=True) # type: ignore
print(colored("*" * len(func_print), "green"), flush=True)
else:
content = message.get("content") # type: ignore
if content is not None:
# if "context" in message:
# content = OpenAIWrapper.instantiate(
# content,
# message["context"],
# self.llm_config and self.llm_config.get("allow_format_str_template", False),
# )
print(content, flush=True)
if "function_call" in message:
function_call = dict(message["function_call"]) # type: ignore
func_print = f"***** Suggested function Call: {function_call.get('name', '(No function name found)')} *****"
print(colored(func_print, "green"), flush=True)
print(
"Arguments: \n",
function_call.get("arguments", "(No arguments found)"),
flush=True,
sep="",
)
print(colored("*" * len(func_print), "green"), flush=True)
print("\n", "-" * 80, flush=True, sep="")
def test_get_messages() -> None:
initial_team.initiate_chat()
print("*" * 200)
print("*" * 200)
print("*" * 200)
all_messages = initial_team.manager.chat_messages[initial_team.members[0]]
for message in all_messages:
_print_received_message(message=message)
| [] |
2024-01-10 | airtai/captn-backend | application.py | from dotenv import load_dotenv
from fastapi import FastAPI
load_dotenv()
import captn.captn_agents # noqa
import google_ads # noqa
import openai_agent # noqa
app = FastAPI()
app.include_router(openai_agent.router, prefix="/openai", tags=["OpenAI"])
app.include_router(google_ads.router, tags=["Google Ads"])
app.include_router(captn.captn_agents.router, tags=["Captn Agents"])
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=9000) # nosec [B104]
| [] |
2024-01-10 | airtai/captn-backend | openai_agent~application.py | import json
from os import environ
from typing import Dict, List, Optional, Union
from fastapi import APIRouter, BackgroundTasks, HTTPException
from openai import AsyncAzureOpenAI
from pydantic import BaseModel
from captn.captn_agents.backend.teams_manager import (
create_team,
get_team_status,
)
from captn.google_ads.client import get_google_ads_team_capability
router = APIRouter()
# Setting up Azure OpenAI instance
aclient = AsyncAzureOpenAI(
api_key=environ.get("AZURE_OPENAI_API_KEY_CANADA"),
azure_endpoint=environ.get("AZURE_API_ENDPOINT"), # type: ignore
api_version=environ.get("AZURE_API_VERSION"),
)
CUSTOMER_BRIEF_DESCRIPTION = """
A structured customer brief, adhering to industry standards for a digital marketing campaign. Organize the information under the following headings:
Business:
Goal:
Current Situation:
Website:
Digital Marketing Objectives:
Next Steps:
Any Other Information Related to Customer Brief:
Please extract and represent relevant details from the conversation under these headings
"""
SYSTEM_PROMPT = f"""
You are Captn AI, a digital marketing assistant for small businesses. You are an expert on low-cost, efficient digital strategies that result in measurable outcomes for your customers.
As you start the conversation with a new customer, you will try to find out more about their business and you MUST capture the following details as part of the conversation without fail:
- What is the customer's business?
- Customer's digital marketing goals?
- Customer's website link, if the customer has one
- Whether the customer uses Google Ads or not
- Customer's permission to access their Google Ads account
- You MUST only use the functions that have been provided to you to respond to the customer. You will be penalised if you try to generate a response on your own without using the given functions.
Failing to capture the above information will result in a penalty.
YOUR CAPABILITIES:
{get_google_ads_team_capability()}
Use the 'get_digital_marketing_campaign_support' function to utilize the above capabilities. Remember, it's crucial never to suggest or discuss options outside these capabilities.
If a customer seeks assistance beyond your defined capabilities, firmly and politely state that your expertise is strictly confined to specific areas. Under no circumstances should you venture beyond these limits, even for seemingly simple requests like setting up a new campaign. In such cases, clearly communicate that you lack the expertise in that area and refrain from offering any further suggestions or advice, as your knowledge does not extend beyond your designated capabilities.
IMPORTANT:
As Captn AI, it is imperative that you adhere to the following guidelines and only use the functions that have been provided to you to respond to the customer without exception:
GUIDELINES:
- Use of Functions: You MUST only use the functions that have been provided to you to respond to the customer. You will be penalised if you try to generate a response on your own without using the function.
- Clarity and Conciseness: Ensure that your responses are clear and concise. Use straightforward questions to prevent confusion.
- One Question at a Time: You MUST ask only one question at once. You will be penalized if you ask more than one question at once to the customer.
- Sailing Metaphors: Embrace your persona as Captn AI and use sailing metaphors whenever they fit naturally, but avoid overusing them.
- Respectful Language: Always be considerate in your responses. Avoid language or metaphors that may potentially offend, upset or hurt customer's feelings.
- Offer within Capability: You MUST provide suggestions and guidance that are within the bounds of your capabilities. You will be penalised if your suggestions are outside of your capabilities.
- Request for campaign optimization: You MUST alyaws ask the customer if they would like to optimize their campaigns before proceeding. You can only proceed in optimising a campaign only if the customer explicitly gives you a permission for that task. This is a mandatory requirement.
- Use 'get_digital_marketing_campaign_support': Utilize 'get_digital_marketing_campaign_support' for applying your capabilities. You MUST explicitly ask permission to customer before using your capabilities. This is a mandatory requirement.
- Use 'respond_to_customer': You MUST call 'respond_to_customer' function when there is no need to use 'get_digital_marketing_campaign_support' function. Else you will be penalised. This is a mandatory requirement.
- Confidentiality: Avoid disclosing the use of 'get_digital_marketing_campaign_support' and 'respond_to_customer' to the customer.
- Customer Approval: You MUST get the customer's approval before taking any actions. Otherwise you will be penalized.
- Markdown Formatting: Format your responses in markdown for an accessible presentation on the web.
- Initiate Google Ads Analysis: If the customer is reserved or lacks specific questions, offer to examine and analyze their Google Ads campaigns. No need to ask for customer details; Captn AI can access all necessary information. All you need is user's permission for campaign analysis. You will be penalised if you start your campaign alanysis without user's permission.
- Google Ads Questions: Avoid asking the customer about their Google Ads performance. Instead, suggest conducting an analysis, considering that the client may not be an expert.
- Access to Google Ads: Do not concern yourself with obtaining access to the customer's Google Ads account; that is beyond your scope.
- Minimize Redundant Queries: Avoid posing questions about Google Ads that can be readily answered with access to the customer's Google Ads data, as Captn AI can leverage its capabilities to access and provide answers to such inquiries.
- Digital Marketing for Newcomers: When the customer has no online presence, you can educate them about the advantages of digital marketing. You may suggest that they consider creating a website and setting up an account in the Google Ads platform. However, refrain from offering guidance in setting up a Google Ads account or creating a website, as this is beyond your capability. Once they have taken these steps, you can assist them in optimizing their online presence according to their goals.
Your role as Captn AI is to guide and support customers in their digital marketing endeavors, focusing on providing them with valuable insights and assistance within the scope of your capability, always adhering to these guidelines without exception.
"""
TEAM_NAME = "google_adsteam{}{}"
async def get_digital_marketing_campaign_support(
user_id: int,
chat_id: int,
customer_brief: str,
background_tasks: BackgroundTasks,
) -> Dict[str, Union[Optional[str], int, List[str]]]:
# team_name = f"GoogleAdsAgent_{conv_id}"
team_name = TEAM_NAME.format(user_id, chat_id)
await create_team(user_id, chat_id, customer_brief, team_name, background_tasks)
return {
# "content": "I am presently treading the waters of your request. Kindly stay anchored, and I will promptly return to you once I have information to share.",
"team_status": "inprogress",
"team_name": team_name,
"team_id": chat_id,
}
async def respond_to_customer(
answer_to_customer_query: str, next_steps: List[str], is_open_ended_query: bool
) -> Dict[str, Union[str, List[str]]]:
next_steps = [""] if is_open_ended_query else next_steps
return {
"content": answer_to_customer_query,
"smart_suggestions": next_steps,
}
SMART_SUGGESTION_DESCRIPTION = """
### INSTRUCTIONS ###
- Possible next steps (atmost three) for the customers. Your next steps MUST be a list of strings. You MUST only use the functions that have been provided to you to respond.
- Your next steps MUST be unique and brief ideally in as little few words as possible. Preferrably with affermative and negative answers.
- You MUST always try to propose the next steps using the functions that have been provided to you. You will be penalised if you try to generate a response on your own without using the function.
- The below ###Example### is for your reference and you can use it to learn. Never ever use the exact 'answer_to_customer_query' in your response. You will be penalised if you do so.
###Example###
answer_to_customer_query: What goals do you have for your marketing efforts?
next_steps: ["Boost sales", "Increase brand awareness", "Drive website traffic"]
answer_to_customer_query: Books are treasures that deserve to be discovered by avid readers. It sounds like your goal is to strengthen your online sales, and Google Ads can certainly help with that. Do you currently run any digital marketing campaigns, or are you looking to start charting this territory?
next_steps: ["Yes, actively running campaigns", "No, we're not using digital marketing", "Just started with Google Ads"]
answer_to_customer_query: It's an exciting venture to dip your sails into the world of Google Ads, especially as a new navigator. To get a better sense of direction, do you have a website set up for your flower shop?
next_steps: ["Yes, we have a website", "No, we don't have a website"]
answer_to_customer_query: Is there anything else you would like to analyze or optimize within your Google Ads campaigns?
next_steps: ["No further assistance needed", "Yes, please help me with campaign optimization"]
answer_to_customer_query: How can I assist you further today?
next_steps: ["No further assistance needed", "Yes, please help me with campaign optimization"]
answer_to_customer_query: When you're ready to optimize, I'm here to help chart the course to smoother waters for your online sales.
next_steps: ["No further assistance needed", "Yes, please help me with campaign optimization"]
"""
IS_OPEN_ENDED_QUERY_DESCRIPTION = """
This is a boolean value. Set it to true if the "answer_to_customer_query" is open ended. Else set it to false. Below are the instructions and a few examples for your reference.
### INSTRUCTIONS ###
- A "answer_to_customer_query" is open-ended if it asks for specific information that cannot be easily guessed (e.g., website links)
- A "answer_to_customer_query" is non-open-ended if it does not request specific details that are hard to guess.
### Example ###
answer_to_customer_query: What goals do you have for your marketing efforts?
is_open_ended_query: false
answer_to_customer_query: Is there anything else you would like to analyze or optimize within your Google Ads campaigns?
is_open_ended_query: false
answer_to_customer_query: answer_to_customer_query: Brilliant! Having a website is like having an online flagship ready to showcase your floral wonders. Could you please share the link to your website? It'll help me to better understand your online presence.
is_open_ended_query: true
answer_to_customer_query: Do you have a website?
is_open_ended_query: false
"""
FUNCTIONS = [
{
"name": "get_digital_marketing_campaign_support",
"description": "Gets specialized assistance for resolving digital marketing and digital advertising campaign inquiries.",
"parameters": {
"type": "object",
"properties": {
"customer_brief": {
"type": "string",
"description": CUSTOMER_BRIEF_DESCRIPTION,
}
},
"required": ["customer_brief"],
},
},
{
"name": "respond_to_customer",
"description": "You MUST use this function when there is no need to use 'get_digital_marketing_campaign_support' function.",
"parameters": {
"type": "object",
"properties": {
"answer_to_customer_query": {
"type": "string",
"description": "Your reply to customer's question. This cannot be empty.",
},
"next_steps": {
"type": "string",
"description": SMART_SUGGESTION_DESCRIPTION,
},
"is_open_ended_query": {
"type": "boolean",
"description": IS_OPEN_ENDED_QUERY_DESCRIPTION,
},
},
"required": [
"answer_to_customer_query",
"next_steps",
"is_open_ended_query",
],
},
},
]
ADDITIONAL_SYSTEM_MSG = """
### ADDITIONAL INSTRUCTIONS ###:
You MUST only use the functions that have been provided to you to respond to the customer. You will be penalised if you try to generate a response on your own without using the function.
You will be penalized if you ask more than one question at once to the customer.
Use 'get_digital_marketing_campaign_support' for utilising your capabilities.
Use MUST use the "get_digital_marketing_campaign_support" function only when necessary, based strictly on the customer's latest message. Do not reference past conversations. Else you will be penalised.
You MUST explicitly ask permission to customer before using your capabilities. This is a mandatory requirement.
Use MUST always call 'respond_to_customer' function when there is no need to use 'get_digital_marketing_campaign_support' function. Else you will be penalised.
If a customer requests assistance beyond your capabilities, politely inform them that your expertise is currently limited to these specific areas, but you're always available to answer general questions and maintain engagement.
"""
async def _get_openai_response(
user_id: int,
chat_id: int,
message: List[Dict[str, str]],
background_tasks: BackgroundTasks,
) -> Dict[str, Union[Optional[str], int, List[str]]]:
try:
messages = [{"role": "system", "content": SYSTEM_PROMPT}] + message
messages.append(
{
"role": "system",
"content": ADDITIONAL_SYSTEM_MSG,
}
)
completion = await aclient.chat.completions.create(model=environ.get("AZURE_MODEL"), messages=messages, functions=FUNCTIONS) # type: ignore
except Exception as e:
raise HTTPException(
status_code=500, detail=f"Internal server error: {e}"
) from e
response_message = completion.choices[0].message
# Check if the model wants to call a function
if response_message.function_call:
# Call the function. The JSON response may not always be valid so make sure to handle errors
function_name = (
response_message.function_call.name
) # todo: enclose in try catch???
available_functions = {
"get_digital_marketing_campaign_support": get_digital_marketing_campaign_support,
"respond_to_customer": respond_to_customer,
}
function_to_call = available_functions[function_name]
# verify function has correct number of arguments
function_args = json.loads(response_message.function_call.arguments)
if function_name == "get_digital_marketing_campaign_support":
function_response = await function_to_call( # type: ignore
user_id=user_id,
chat_id=chat_id,
background_tasks=background_tasks,
**function_args,
)
else:
function_response = await function_to_call( # type: ignore
**function_args,
)
return function_response # type: ignore
else:
result: str = completion.choices[0].message.content # type: ignore
return {"content": result, "smart_suggestions": [""]}
async def _user_response_to_agent(
user_id: int,
chat_id: int,
message: List[Dict[str, str]],
background_tasks: BackgroundTasks,
) -> Dict[str, Union[Optional[str], int]]:
last_user_message = message[-1]["content"]
team_name = TEAM_NAME.format(user_id, chat_id)
await create_team(
user_id,
chat_id,
last_user_message,
team_name,
background_tasks,
)
return {
# "content": "I am presently treading the waters of your request. Kindly stay anchored, and I will promptly return to you once I have information to share.",
"team_status": "inprogress",
"team_name": team_name,
"team_id": chat_id,
}
class AzureOpenAIRequest(BaseModel):
chat_id: int
message: List[Dict[str, str]]
user_id: int
team_id: Union[int, None]
@router.post("/chat")
async def chat(
request: AzureOpenAIRequest, background_tasks: BackgroundTasks
) -> Dict[str, Union[Optional[str], int, List[str]]]:
message = request.message
chat_id = request.chat_id
result = (
await _user_response_to_agent(
request.user_id,
chat_id,
message,
background_tasks,
)
if (request.team_id)
else await _get_openai_response(
request.user_id, chat_id, message, background_tasks
)
)
return result # type: ignore
class GetTeamStatusRequest(BaseModel):
team_id: int
@router.post("/get-team-status")
async def get_status(
request: GetTeamStatusRequest,
) -> Dict[str, Union[str, bool, int, List[str]]]:
team_id = request.team_id
status = await get_team_status(team_id)
return status
| [
"f\"\"\"\nYou are Captn AI, a digital marketing assistant for small businesses. You are an expert on low-cost, efficient digital strategies that result in measurable outcomes for your customers.\n\nAs you start the conversation with a new customer, you will try to find out more about their business and you MUST capture the following details as part of the conversation without fail:\n- What is the customer's business?\n- Customer's digital marketing goals?\n- Customer's website link, if the customer has one\n- Whether the customer uses Google Ads or not\n- Customer's permission to access their Google Ads account\n- You MUST only use the functions that have been provided to you to respond to the customer. You will be penalised if you try to generate a response on your own without using the given functions.\n\nFailing to capture the above information will result in a penalty.\n\n\nYOUR CAPABILITIES:\n\n{get_google_ads_team_capability()}\n\n\nUse the 'get_digital_marketing_campaign_support' function to utilize the above capabilities. Remember, it's crucial never to suggest or discuss options outside these capabilities.\nIf a customer seeks assistance beyond your defined capabilities, firmly and politely state that your expertise is strictly confined to specific areas. Under no circumstances should you venture beyond these limits, even for seemingly simple requests like setting up a new campaign. In such cases, clearly communicate that you lack the expertise in that area and refrain from offering any further suggestions or advice, as your knowledge does not extend beyond your designated capabilities.\n\nIMPORTANT:\n\nAs Captn AI, it is imperative that you adhere to the following guidelines and only use the functions that have been provided to you to respond to the customer without exception:\n\nGUIDELINES:\n\n- Use of Functions: You MUST only use the functions that have been provided to you to respond to the customer. You will be penalised if you try to generate a response on your own without using the function.\n- Clarity and Conciseness: Ensure that your responses are clear and concise. Use straightforward questions to prevent confusion.\n- One Question at a Time: You MUST ask only one question at once. You will be penalized if you ask more than one question at once to the customer.\n- Sailing Metaphors: Embrace your persona as Captn AI and use sailing metaphors whenever they fit naturally, but avoid overusing them.\n- Respectful Language: Always be considerate in your responses. Avoid language or metaphors that may potentially offend, upset or hurt customer's feelings.\n- Offer within Capability: You MUST provide suggestions and guidance that are within the bounds of your capabilities. You will be penalised if your suggestions are outside of your capabilities.\n- Request for campaign optimization: You MUST alyaws ask the customer if they would like to optimize their campaigns before proceeding. You can only proceed in optimising a campaign only if the customer explicitly gives you a permission for that task. This is a mandatory requirement.\n- Use 'get_digital_marketing_campaign_support': Utilize 'get_digital_marketing_campaign_support' for applying your capabilities. You MUST explicitly ask permission to customer before using your capabilities. This is a mandatory requirement.\n- Use 'respond_to_customer': You MUST call 'respond_to_customer' function when there is no need to use 'get_digital_marketing_campaign_support' function. Else you will be penalised. This is a mandatory requirement.\n- Confidentiality: Avoid disclosing the use of 'get_digital_marketing_campaign_support' and 'respond_to_customer' to the customer.\n- Customer Approval: You MUST get the customer's approval before taking any actions. Otherwise you will be penalized.\n- Markdown Formatting: Format your responses in markdown for an accessible presentation on the web.\n- Initiate Google Ads Analysis: If the customer is reserved or lacks specific questions, offer to examine and analyze their Google Ads campaigns. No need to ask for customer details; Captn AI can access all necessary information. All you need is user's permission for campaign analysis. You will be penalised if you start your campaign alanysis without user's permission.\n- Google Ads Questions: Avoid asking the customer about their Google Ads performance. Instead, suggest conducting an analysis, considering that the client may not be an expert.\n- Access to Google Ads: Do not concern yourself with obtaining access to the customer's Google Ads account; that is beyond your scope.\n- Minimize Redundant Queries: Avoid posing questions about Google Ads that can be readily answered with access to the customer's Google Ads data, as Captn AI can leverage its capabilities to access and provide answers to such inquiries.\n- Digital Marketing for Newcomers: When the customer has no online presence, you can educate them about the advantages of digital marketing. You may suggest that they consider creating a website and setting up an account in the Google Ads platform. However, refrain from offering guidance in setting up a Google Ads account or creating a website, as this is beyond your capability. Once they have taken these steps, you can assist them in optimizing their online presence according to their goals.\n\nYour role as Captn AI is to guide and support customers in their digital marketing endeavors, focusing on providing them with valuable insights and assistance within the scope of your capability, always adhering to these guidelines without exception.\n",
"[{\"role\": \"system\", \"content\": SYSTEM_PROMPT}] + message",
"\n### ADDITIONAL INSTRUCTIONS ###:\nYou MUST only use the functions that have been provided to you to respond to the customer. You will be penalised if you try to generate a response on your own without using the function.\nYou will be penalized if you ask more than one question at once to the customer.\nUse 'get_digital_marketing_campaign_support' for utilising your capabilities.\nUse MUST use the \"get_digital_marketing_campaign_support\" function only when necessary, based strictly on the customer's latest message. Do not reference past conversations. Else you will be penalised.\nYou MUST explicitly ask permission to customer before using your capabilities. This is a mandatory requirement.\nUse MUST always call 'respond_to_customer' function when there is no need to use 'get_digital_marketing_campaign_support' function. Else you will be penalised.\nIf a customer requests assistance beyond your capabilities, politely inform them that your expertise is currently limited to these specific areas, but you're always available to answer general questions and maintain engagement.\n"
] |
2024-01-10 | airtai/captn-backend | captn~captn_agents~backend~team.py | import json
from typing import Any, Callable, Dict, List, Optional
import autogen
import openai
from fastcore.basics import patch
from .config import CONFIG_LIST
_completions_create_original = autogen.oai.client.OpenAIWrapper._completions_create
# WORKAROUND for consistent 500 eror code when using openai functions
@patch # type: ignore
def _completions_create(
self: autogen.oai.client.OpenAIWrapper,
client: openai.OpenAI,
params: Dict[str, Any],
) -> Any:
for message in params["messages"]:
name = message.get("name")
role = message.get("role")
if name and role != "function":
# print(f"Removing name parameter from the following message:\n{message}")
message.pop("name")
tokens_per_request = autogen.token_count_utils.count_token(
params["messages"], model="gpt-4-1106-preview"
)
print(f"Tokens per request: {tokens_per_request}")
return _completions_create_original(self, client=client, params=params)
class Team:
_team_name_counter: int = 0
_functions: Optional[List[Dict[str, Any]]] = None
_teams: Dict[str, "Team"] = {}
@staticmethod
def _store_team(team_name: str, team: "Team") -> None:
if team_name in Team._teams:
raise ValueError(f"Team name '{team_name}' already exists")
Team._teams[team_name] = team
@staticmethod
def get_team(team_name: str) -> "Team":
try:
return Team._teams[team_name]
except KeyError as e:
raise ValueError(f"Unknown team name: '{team_name}'") from e
@staticmethod
def get_user_conv_team_name(name_prefix: str, user_id: int, conv_id: int) -> str:
name = f"{name_prefix}_{str(user_id)}_{str(conv_id)}"
return name
def __init__(
self,
roles: List[Dict[str, str]],
name: str,
function_map: Optional[Dict[str, Callable[[Any], Any]]] = None,
work_dir: str = "my_default_workdir",
max_round: int = 80,
seed: int = 42,
temperature: float = 0.2,
human_input_mode: str = "NEVER",
):
self.roles = roles
self.initial_message: str
self.name: str
self.max_round = max_round
self.seed = seed
self.temperature = temperature
self.function_map = function_map
self.work_dir = work_dir
self.llm_config: Optional[Dict[str, Any]] = None
self.name = name
self.human_input_mode = human_input_mode
Team._store_team(self.name, self)
@classmethod
def _get_new_team_name(cls) -> str:
name_prefix = cls._get_team_name_prefix()
name = f"{name_prefix}_{cls._team_name_counter}"
cls._team_name_counter = cls._team_name_counter + 1
return name
@classmethod
def _get_team_name_prefix(cls) -> str:
raise NotImplementedError()
@classmethod
def get_llm_config(cls, seed: int = 42, temperature: float = 0.2) -> Dict[str, Any]:
llm_config = {
"config_list": CONFIG_LIST,
"seed": seed,
"temperature": temperature,
"functions": cls._functions,
# "request_timeout": 800,
}
return llm_config
def _create_groupchat_and_manager(self) -> None:
manager_llm_config = self.llm_config.copy() # type: ignore
# GroupChatManager is not allowed to make function/tool calls (from version 0.2.2).
manager_llm_config.pop("functions", None)
manager_llm_config.pop("tools", None)
self.groupchat = autogen.GroupChat(
agents=self.members, messages=[], max_round=self.max_round
)
self.manager = autogen.GroupChatManager(
groupchat=self.groupchat,
llm_config=manager_llm_config,
is_termination_msg=self._is_termination_msg,
)
def _create_members(self) -> None:
self.members = [
self._create_member(role["Name"], role["Description"])
for role in self.roles
]
self._create_groupchat_and_manager()
@staticmethod
def _is_termination_msg(x: Dict[str, Optional[str]]) -> bool:
content = x.get("content")
if content is None:
return False
content_xs = content.split()
return len(content_xs) > 0 and (
"TERMINATE" in content_xs[-1] or "PAUSE" in content_xs[-1]
)
def _create_member(
self,
name: str,
description: str,
is_user_proxy: bool = False,
) -> autogen.ConversableAgent:
name = name.lower().replace(" ", "_")
system_message = f"""You are {name}, {description}
Your task is to chat with other team mambers and try to solve the given task.
Do NOT try to finish the task until other team members give their opinion.
"""
if is_user_proxy:
return autogen.UserProxyAgent(
human_input_mode=self.human_input_mode,
name=name,
llm_config=self.llm_config,
system_message=system_message,
is_termination_msg=self._is_termination_msg,
)
return autogen.AssistantAgent(
name=name,
llm_config=self.llm_config,
system_message=system_message,
is_termination_msg=self._is_termination_msg,
code_execution_config={"work_dir": self.work_dir},
function_map=self.function_map,
)
@property
def _first_section(self) -> str:
roles = ", ".join([str(member.name) for member in self.members])
return f"""The team is consisting of the following roles: {roles}.
Play to your strengths as an LLM and pursue simple strategies with no legal complications.
"""
@property
def _task(self) -> str:
raise NotImplementedError()
@property
def _guidelines(self) -> str:
raise NotImplementedError()
@property
def _constraints(self) -> str:
return """## Constraints
You operate within the following constraints:
1. ~4000 word limit for short term memory. Your short term memory is short, so immediately save important information to files.
2. If you are unsure how you previously did something or want to recall past events, thinking about similar events will help you remember.
3. You can ask and answer questions from other team members or suggest function listed below e.g. command_name
4. The context size is limited so try to be as concise in discussinos as possible. Do not reapeat yourself or others
"""
@property
def _commands(self) -> str:
raise NotImplementedError()
@property
def _resources(self) -> str:
return """## Resources
You can leverage access to the following resources:
1. Long Term memory management.
2. File output.
3. Command execution
"""
@property
def _best_practices(self) -> str:
return """## Best practices
1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.
2. Constructively self-criticize your big-picture behavior constantly.
3. Reflect on past decisions and strategies to refine your approach.
4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.
5. If you have some doubts, ask question.
"""
@property
def _final_section(self) -> str:
return ""
def _create_initial_message(self) -> None:
self.initial_message = f"""{self._task}
{self._first_section}
{self._guidelines}
{self._constraints}
{self._commands}
{self._resources}
{self._best_practices}
{self._final_section}
"""
def initiate_chat(self) -> None:
self.manager.initiate_chat(self.manager, message=self.initial_message)
async def a_initiate_chat(self) -> None:
await self.manager.a_initiate_chat(self.manager, message=self.initial_message)
def get_last_message(self, add_prefix: bool = True) -> str:
last_message = self.groupchat.messages[-1]["content"]
if isinstance(last_message, dict):
last_message = json.dumps(last_message)
last_message = last_message.replace("PAUSE", "").replace("TERMINATE", "")
if add_prefix:
last_message = f"Response from team '{self.name}':\n{last_message}"
return last_message # type: ignore
def continue_chat(self, message: str) -> None:
message = f"Response from the client:\n{message}"
self.manager.send(recipient=self.manager, message=message)
async def a_continue_chat(self, message: str) -> None:
message = f"Response from the client:\n{message}"
await self.manager.a_send(recipient=self.manager, message=message)
| [] |
2024-01-10 | KylinC/ChatFinance | inference_6b.py | from models_server.chatglm2.jina_client import encode
from prompts.intent_recognition import intent_recognition_prompt
from prompts.entity_recognition import entity_recognition_prompt
from prompts.answer_generation import answer_generation_prompt
from prompts.open_question import open_question_prompt
from models_server.text2vec.jina_embedding import JinaEmbeddings
from database_server.weaviate.db import insert_table_uuid,insert_txt_uuid
from langchain.vectorstores import Weaviate
from elasticsearch import Elasticsearch
import weaviate
import json
import os
import glob
def parse_entity_recognition(response: str):
parse_list = []
lines = response.split('\n')
for line in lines:
sep = ':' if ':' in lines[-1] else '：'
if "公司名" in line:
parse_list.append(line.split(sep)[1])
if "年份" in line:
parse_list.append(line.split(sep)[1])
return parse_list
def parse_intent_recognition(response: str):
lines = response.split('\n')
return lines[-1]
def attain_uuid(entities, uuid_dict):
for k, v in uuid_dict.items():
fg = True
for entity in entities:
if entity not in k:
fg = False
break
if fg:
print(entities, k)
return v, k
return None, None
def generate(question, uuid_dict, crawl_dict, crawl_name_dict, es, log_file):
log_file.write("= = 流程开始 = = \n")
log_file.write(f"Q:\n{question}\n\n")
# -> Intent Recognition
log_file.write("= = 意图识别 = = \n")
prompt = intent_recognition_prompt(question)
response = encode(prompt, history=[])
log_file.write(f"R:\n{response[0].text}\n\n")
if "检索问题" not in parse_intent_recognition(response[0].text):
log_file.write("开放问题直接作答\n")
prompt = open_question_prompt(question)
response = encode(prompt, history=[])
answer = response[0].text
log_file.write(f"R:\n{answer}\n\n")
return answer
# print("意图识别时间：",time.time()-initial_time)
############################ -> Entity Recognition
try_year_list = ["2021年","2022年"]
log_file.write("= = 实体提取 = = \n")
prompt = entity_recognition_prompt(question)
response = encode(prompt, history=[])
log_file.write(f"R:\n{response[0].text}\n\n")
entities = parse_entity_recognition(response[0].text)
uuid, file_name = attain_uuid(entities, uuid_dict)
log_file.write(f"R:\n{uuid}\n\n")
if not uuid and entities[0][0] == '年':
entities[0] = entities[0][1:]
uuid, file_name = attain_uuid(entities, uuid_dict)
log_file.write(f"R:\n 1)首字修复，修复公司名称： {entities[0]}\n\n")
# if not uuid:
# for try_year in try_year_list:
# old_year = entities[1]
# entities[1] = try_year
# uuid, file_name = attain_uuid(entities, uuid_dict)
# if uuid:
# log_file.write(f"R:\n 2)年份修复，{old_year} 改为 {entities[1]},uuid:{uuid}\n\n")
# break
if not uuid:
log_file.write("未知公司不予作答\n")
return ""
# print("实体提取时间：",time.time()-initial_time)
extra_information_list = []
################################ -> ElasticSearch
log_file.write("= = ElasticSearch = = \n")
# index_name = f"{uuid}"
# # index_name = "all_property"
# try:
# for word in entities:
# replaced_question = question.replace(word, '')
# search_query = {
# "query": {
# "match": {
# "text": replaced_question
# }
# }
# }
# search_resp = es.search(index=index_name, body=search_query)
# docs = search_resp["hits"]["hits"][:3]
# for i, e in enumerate(docs):
# property_name = e['_source']['text']
# company = crawl_name_dict[file_name]
# year = file_name.split("__")[4]+"报"
# property_value = crawl_dict[company][year][property_name]
# # if not property_value or property_value in ["None", "null"]:
# # continue
# log_file.write(
# f"ES: = = = = = = = = = = = k[{i}] = = = = = = = = = = =\n")
# log_file.write(e['_source']['text'])
# log_file.write("\n")
# extra_information_list.append(f"{property_name}是{property_value}")
# except:
# log_file.write("数据库暂未录入\n")
##################################### -> Embedding 尝试注入
if not extra_information_list:
# if True:
log_file.write("= = EmbeddingInsert(Table) = = \n")
Embedding_Match = False
if entities[1][-1]=="年":
target_year = entities[1][:-1]
target_name = entities[0]
log_file.write(f"尝试搜索{target_year}*{target_name}*.cal\n")
try:
target_dir = "/home/kylin/workspace/ChatFinance/data/chatglm_llm_fintech_raw_dataset/alltable"
# pattern = rf'^{target_year}.*{target_name}.*\.cal$'
pattern = os.path.join(target_dir, f"{target_year}*{target_name}*.cal")
matched_files = [os.path.abspath(path) for path in glob.glob(pattern)]
insert_table_uuid(matched_files[0],uuid,client,embedding)
log_file.write(f"搜索Table注入成功,匹配文件名字：{matched_files[0]}\n")
Embedding_Match = True
except:
log_file.write("搜索不到相关.cal文件\n")
# log_file.write("= = EmbeddingInsert(Txt) = = \n")
# log_file.write(f"尝试搜索{target_year}*{target_name}*.txt\n")
# try:
# target_dir = "/home/kylin/workspace/ChatFinance/data/chatglm_llm_fintech_raw_dataset/alldata"
# # pattern = rf'^{target_year}.*{target_name}.*\.txt$'
# pattern = os.path.join(target_dir, f"{target_year}*{target_name}*.txt")
# matched_files = [os.path.abspath(path) for path in glob.glob(pattern)]
# insert_txt_uuid(matched_files[0],uuid,client,embedding)
# log_file.write(f"搜索Txt注入成功,匹配文件名字：{matched_files[0]}\n")
# except:
# log_file.write("搜索不到相关.Txt文件\n")
##################################### -> Embedding Database
if not extra_information_list and Embedding_Match:
# if Embedding_Match:
log_file.write("= = EmbeddingDatabase = = \n")
index_name = f"LangChain_{uuid}"
try:
db = Weaviate(client=client, embedding=embedding,
index_name=index_name, text_key="text", by_text=False)
for word in entities:
replaced_question = question.replace(word, '')
docs = db.similarity_search(replaced_question, k=5)
for i, e in enumerate(docs):
log_file.write(
f"ED: = = = = = = = = = k[{i}] = = = = = = = = =\n")
log_file.write(e.page_content)
log_file.write("\n")
extra_information_list.append(e.page_content)
except:
log_file.write("数据库暂未录入\n")
# print("向量库搜索时间：",time.time()-initial_time)
log_file.write("= = AnswerGeneration = = \n")
extra_information = "\n".join(extra_information_list)
log_file.write(extra_information+'\n')
prompt = answer_generation_prompt(extra_information, question)
response = encode(prompt, history=[])
log_file.write(f"R:\n{response[0].text}\n\n")
answer=response[0].text
return answer
# import time
# initial_time = time.time()
# -> Init Embedding Database
embedding = JinaEmbeddings("127.0.0.1")
client = weaviate.Client(
url="http://localhost:50003", # Replace with your endpoint
auth_client_secret=weaviate.AuthApiKey(api_key="vdb-secret-key"))
# print("向量库时间：",time.time()-initial_time)
# -> Init Embedding Database
es = Elasticsearch('http://localhost:50004')
# print("es时间：",time.time()-initial_time)
# -> Init UUID Dict
with open("./data/chatglm_llm_fintech_raw_dataset/uuid.json", "r") as f:
uuid_dict = json.load(f)
# -> Init crawl Dict
with open("./data/chatglm_llm_fintech_raw_dataset/allcrawl.json", "r") as f:
crawl_dict = json.load(f)
with open("./data/chatglm_llm_fintech_raw_dataset/name_map_crawl.json", "r") as f:
crawl_name_dict = json.load(f)
# print("dict时间：",time.time()-initial_time)
# question = "本钢板材在2020年对联营企业和合营企业的投资收益是多少元？"
import time
from datetime import datetime
formatted_time = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
bad_ids = [0, 1, 4, 5, 10, 11, 13, 17, 21, 25, 29, 32, 37, 41, 51, 59, 61, 64, 67, 69, 71, 102, 106, 108, 115, 127, 133, 135, 141, 146, 148, 150, 152, 160, 161, 168, 170, 174, 177, 180, 183, 184, 186, 188, 194, 195, 196, 198, 210, 214, 215, 219, 222, 228, 237, 239, 240, 245, 252, 257, 259, 260, 267, 270, 271, 273, 276, 277, 278, 280, 281, 289, 295, 303, 305, 315, 332, 343, 346, 347, 361, 362, 367, 368, 370, 379, 382, 383, 393, 396, 405, 409, 416, 417, 419, 428, 429, 434, 435, 436, 438, 439, 444, 447, 448, 451, 454, 465, 470, 474, 483, 490, 495, 515, 520, 526, 530, 531, 538, 540, 541, 551, 554, 555, 556, 567, 573, 576, 581, 583, 586, 587, 590, 594, 596, 618, 619, 621, 626, 632, 634, 641, 642, 648, 653, 654, 656, 663, 667, 668, 675, 676, 683, 692, 705, 708, 714, 719, 723, 724, 726, 727, 729, 732, 733, 753, 754, 773, 776, 780, 781, 785, 793, 797, 798, 799, 801, 802, 804, 806, 811, 812, 814, 819, 822, 847, 849, 854, 856, 860, 865, 868, 870, 880, 887, 905, 906, 914, 915, 919, 924, 935, 946, 948, 951, 953, 957, 961, 970, 984, 987, 988, 989, 990, 995, 998, 1009, 1011, 1014, 1016, 1022, 1023, 1027, 1032, 1039, 1041, 1043, 1045, 1047, 1048, 1049, 1051, 1054, 1055, 1058, 1060, 1062, 1066, 1067, 1068, 1069, 1072, 1073, 1074, 1078, 1083, 1084, 1088, 1090, 1091, 1093, 1095, 1099, 1102, 1103, 1104, 1121, 1128, 1130, 1131, 1135, 1144, 1146, 1158, 1161, 1162, 1167, 1169, 1171, 1175, 1176, 1178, 1181, 1182, 1186, 1187, 1190, 1193, 1194, 1198, 1199, 1200, 1201, 1203, 1205, 1207, 1208, 1211, 1221, 1227, 1228, 1230, 1232, 1234, 1238, 1242, 1243, 1245, 1247, 1248, 1253, 1258, 1259, 1260, 1261, 1267, 1268, 1269, 1270, 1271, 1277, 1279, 1285, 1290, 1291, 1295, 1296, 1299, 1301, 1302, 1308, 1310, 1312, 1315, 1316, 1320, 1321, 1322, 1323, 1324, 1326, 1328, 1329, 1330, 1332, 1333, 1334, 1338, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1350, 1356, 1357, 1362, 1364, 1365, 1372, 1374, 1377, 1383, 1384, 1385, 1393, 1395, 1400, 1407, 1410, 1412, 1413, 1421, 1423, 1426, 1428, 1438, 1439, 1440, 1442, 1444, 1446, 1453, 1457, 1458, 1459, 1460, 1466, 1474, 1479, 1480, 1481, 1492, 1493, 1495, 1496, 1504, 1505, 1507, 1508, 1510, 1514, 1519, 1522, 1531, 1536, 1540, 1543, 1545, 1549, 1550, 1556, 1558, 1559, 1563, 1564, 1565, 1570, 1574, 1576, 1577, 1582, 1587, 1588, 1594, 1595, 1598, 1599, 1603, 1604, 1606, 1608, 1613, 1614, 1615, 1616, 1624, 1629, 1630, 1633, 1637, 1647, 1651, 1660, 1662, 1665, 1670, 1671, 1673, 1678, 1680, 1681, 1683, 1686, 1693, 1696, 1698, 1701, 1702, 1705, 1708, 1710, 1711, 1716, 1720, 1722, 1728, 1732, 1741, 1742, 1744, 1751, 1754, 1757, 1758, 1760, 1762, 1764, 1767, 1771, 1774, 1777, 1781, 1783, 1790, 1791, 1794, 1797, 1800, 1804, 1805, 1808, 1809, 1810, 1811, 1817, 1820, 1825, 1826, 1827, 1830, 1831, 1833, 1837, 1846, 1850, 1852, 1856, 1858, 1864, 1868, 1872, 1874, 1875, 1876, 1881, 1883, 1885, 1889, 1892, 1893, 1896, 1897, 1901, 1910, 1911, 1914, 1919, 1920, 1926, 1929, 1932, 1938, 1940, 1942, 1943, 1945, 1946, 1952, 1958, 1961, 1962, 1963, 1964, 1965, 1967, 1968, 1971, 1983, 1989, 1996, 1997, 1999, 2002, 2003, 2006, 2014, 2015, 2016, 2025, 2027, 2029, 2031, 2035, 2048, 2062, 2065, 2069, 2071, 2074, 2082, 2086, 2089, 2090, 2092, 2093, 2094, 2096, 2098, 2099, 2105, 2108, 2109, 2111, 2117, 2118, 2119, 2126, 2131, 2132, 2135, 2137, 2142, 2152, 2167, 2182, 2184, 2190, 2199, 2204, 2213, 2214, 2217, 2219, 2221, 2231, 2233, 2234, 2242, 2243, 2244, 2247, 2259, 2268, 2271, 2272, 2282, 2290, 2292, 2294, 2295, 2296, 2297, 2309, 2311, 2312, 2319, 2322, 2324, 2326, 2329, 2333, 2336, 2339, 2340, 2341, 2345, 2346, 2350, 2355, 2367, 2372, 2375, 2379, 2382, 2383, 2386, 2387, 2389, 2402, 2405, 2410, 2413, 2418, 2423, 2425, 2432, 2438, 2440, 2444, 2451, 2452, 2457, 2459, 2463, 2464, 2465, 2467, 2469, 2478, 2480, 2487, 2490, 2502, 2507, 2508, 2509, 2510, 2511, 2517, 2518, 2523, 2530, 2534, 2538, 2539, 2541, 2546, 2548, 2549, 2556, 2559, 2564, 2567, 2570, 2572, 2573, 2575, 2578, 2584, 2586, 2587, 2591, 2598, 2600, 2603, 2611, 2619, 2624, 2629, 2630, 2636, 2640, 2641, 2643, 2644, 2646, 2648, 2655, 2663, 2668, 2671, 2672,
2674, 2677, 2678, 2679, 2680, 2685, 2686, 2687, 2696, 2701, 2708, 2709, 2712, 2713, 2717, 2720, 2725, 2728, 2729, 2732, 2741, 2742, 2743, 2749, 2757, 2761, 2764, 2771, 2774, 2777, 2781, 2782, 2788, 2790, 2791, 2792, 2795, 2796, 2797, 2801, 2803, 2806, 2807, 2810, 2811, 2812, 2816, 2818, 2821, 2835, 2837, 2838, 2844, 2850, 2852, 2855, 2861, 2867, 2877, 2885, 2886, 2890, 2895, 2902, 2904, 2905, 2906, 2908, 2912, 2917, 2919, 2922, 2923, 2924, 2926, 2927, 2928, 2932, 2933, 2946, 2947, 2950, 2951, 2955, 2957, 2959, 2961, 2967, 2968, 2969, 2975, 2978, 2982, 2986, 2991, 2992, 2994, 2996, 2997, 2998, 3006, 3010, 3012, 3013, 3017, 3018, 3019, 3023, 3026, 3029, 3030, 3031, 3036, 3038, 3040, 3043, 3044, 3050, 3051, 3054, 3056, 3062, 3065, 3068, 3071, 3078, 3079, 3080, 3083, 3085, 3086, 3090, 3111, 3112, 3117, 3118, 3119, 3125, 3127, 3128, 3133, 3135, 3137, 3139, 3150, 3153, 3154, 3156, 3158, 3161, 3164, 3166, 3169, 3174, 3177, 3182, 3188, 3190, 3192, 3195, 3199, 3203, 3205, 3208, 3209, 3211, 3212, 3213, 3215, 3216, 3218, 3225, 3226, 3230, 3231, 3237, 3240, 3243, 3244, 3247, 3248, 3252, 3262, 3268, 3273, 3276, 3277, 3281, 3282, 3285, 3286, 3291, 3292, 3293, 3295, 3296, 3298, 3306, 3310, 3314, 3315, 3316, 3318, 3320, 3321, 3323, 3325, 3334, 3340, 3341, 3342, 3343, 3345, 3352, 3353, 3360, 3361, 3362, 3364, 3366, 3370, 3371, 3373, 3376, 3377, 3383, 3384, 3387, 3388, 3392, 3401, 3404, 3411, 3415, 3418, 3419, 3421, 3424, 3427, 3429, 3436, 3437, 3439, 3440, 3445, 3451, 3460, 3461, 3463, 3467, 3480, 3481, 3482, 3493, 3496, 3498, 3500, 3501, 3502, 3504, 3506, 3512, 3513, 3514, 3517, 3518, 3520, 3521, 3522, 3524, 3527, 3537, 3538, 3541, 3547, 3568, 3569, 3572, 3575, 3576, 3579, 3583, 3585, 3588, 3590, 3591, 3594, 3596, 3605, 3622, 3626, 3632, 3633, 3636, 3643, 3644, 3645, 3648, 3649, 3650, 3653, 3656, 3660, 3661, 3663, 3676, 3687, 3695, 3697, 3703, 3705, 3722, 3724, 3730, 3733, 3734, 3736, 3743, 3745, 3748, 3750, 3758, 3759, 3766, 3773, 3791, 3793, 3798, 3799, 3809, 3812, 3813, 3815, 3817, 3819, 3821, 3824, 3829, 3832, 3833, 3837, 3838, 3842, 3847, 3848, 3851, 3852, 3862, 3865, 3870, 3872, 3873, 3875, 3877, 3880, 3881, 3894, 3896, 3899, 3906, 3910, 3913, 3917, 3920, 3923, 3925, 3941, 3944, 3949, 3951, 3969, 3970, 3975, 3976, 3978, 3982, 3986, 3991, 3992, 3997, 3998, 4002, 4012, 4015, 4019, 4020, 4021, 4023, 4024, 4025, 4034, 4035, 4037, 4038, 4039, 4041, 4045, 4049, 4057, 4062, 4063, 4070, 4071, 4074, 4077, 4079, 4080, 4083, 4085, 4086, 4090, 4095, 4100, 4101, 4103, 4106, 4110, 4115, 4121, 4126, 4140, 4143, 4149, 4153, 4158, 4159, 4161, 4167, 4168, 4170, 4173, 4180, 4184, 4191, 4198, 4199, 4204, 4206, 4211, 4213, 4214, 4217, 4221, 4223, 4224, 4226, 4230, 4231, 4232, 4241, 4242, 4244, 4245, 4247, 4248, 4250, 4254, 4259, 4261, 4262, 4263, 4266, 4267, 4271, 4272, 4279, 4286, 4287, 4292, 4299, 4300, 4304, 4305, 4307, 4308, 4310, 4312, 4313, 4314, 4320, 4328, 4332, 4335, 4340, 4344, 4348, 4349, 4351, 4353, 4362, 4364, 4366, 4370, 4372, 4375, 4376, 4379, 4381, 4382, 4384, 4386, 4399, 4400, 4401, 4404, 4408, 4411, 4412, 4413, 4415, 4418, 4419, 4421, 4422, 4434, 4435, 4437, 4439, 4443, 4446, 4447, 4448, 4455, 4456, 4457, 4462, 4463, 4467, 4468, 4471, 4473, 4474, 4477, 4480, 4482, 4485, 4487, 4495, 4497, 4498, 4499, 4503, 4514, 4525, 4526, 4528, 4529, 4532, 4540, 4545, 4548, 4560, 4563, 4565, 4567, 4569, 4571, 4575, 4583, 4584, 4592, 4593, 4596, 4599, 4600, 4601, 4604, 4609, 4616, 4617, 4619, 4625, 4627, 4630, 4636, 4642, 4647, 4651, 4653, 4654, 4657, 4659, 4667, 4672, 4683, 4685, 4686, 4697, 4699, 4700, 4702, 4711, 4714, 4718, 4727, 4729, 4735, 4738, 4739, 4741, 4748, 4751, 4752, 4753, 4763, 4767, 4769, 4776, 4781, 4784, 4788, 4793, 4796, 4797, 4798, 4800, 4808, 4809, 4812, 4816, 4818, 4822, 4826, 4827, 4831, 4832, 4833, 4836, 4837, 4845, 4846, 4847, 4849, 4852, 4855, 4859, 4860, 4861, 4867, 4868, 4869, 4871, 4875, 4876, 4877, 4884, 4891, 4895, 4896, 4907, 4909, 4913, 4918, 4919, 4922, 4926, 4927, 4934, 4935, 4936, 4944, 4945, 4946, 4957, 4959, 4962, 4964, 4965, 4966, 4971, 4973, 4974, 4975, 4985, 4986, 4995, 4999]
with open(f"./logs/log_{formatted_time}.txt", "w") as log_file, open(f"./logs/submission_{formatted_time}.json", "w") as sm_file, open("./data/chatglm_llm_fintech_raw_dataset/test_questions.jsonl", "r") as qs_file:
question_count = 0
for question_line in qs_file:
question_count += 1
##### id 截断
# if question_count<1734:
# continue
print("question_count:",question_count)
question_dict = json.loads(question_line)
##### bad id 截断
if question_dict["id"] not in bad_ids:
continue
answer = generate(question_dict["question"], uuid_dict, crawl_dict, crawl_name_dict, es, log_file)
answer_dict = {"id":question_dict["id"],"question":question_dict["question"],"answer":answer}
sm_file.write(f"{answer_dict}\n")
time.sleep(3)
| [] |
2024-01-10 | KylinC/ChatFinance | models_server~text2vec~jina_embedding.py | import warnings # noqa: E501
warnings.filterwarnings('ignore') # noqa: E501
from langchain.embeddings.base import Embeddings
from docarray import Document, DocumentArray
from jina import Client
from typing import Any, List
class JinaEmbeddings(Embeddings):
def __init__(self, host: str = "0.0.0.0", port: int = 50001, **kwargs: Any) -> None:
self.client = Client(host=host, port=port, **kwargs)
def _post(self, docs: List[Any], **kwargs: Any) -> Any:
payload = dict(inputs=docs, **kwargs)
return self.client.post(on="/", **payload)
def embed_documents(self, texts: List[str]) -> List[List[float]]:
docs = DocumentArray([Document(text=t) for t in texts])
embeddings = self._post(docs).embeddings
return [list(map(float, e)) for e in embeddings]
def embed_query(self, text: str) -> List[float]:
docs = DocumentArray([Document(text=text)])
embedding = self._post(docs).embeddings[0]
return list(map(float, embedding)) | [] |
2024-01-10 | KylinC/ChatFinance | prompts~answer_generation.py | from langchain import PromptTemplate
PROMPT = """
你需要扮演一位金融专家助手。请根据所提供的额外信息，回答下列问题。请注意，额外信息虽然都是有效的，但你只需使用与问题直接相关的部分。
要求：
1. 答案应简练、清晰、准确。
2. 仅使用与问题直接相关的额外信息进行回答。
3. 避免引入与问题无关的信息。
示例：
人类：本钢板材在2020年对联营企业和合营企业的投资收益是多少元？
额外信息：该公司的数据如下所示
其中:对联营企业和合营企业的投资收益/（损失）是374119.86
其中:对联营企业和合营企业的投资收益/（损失） 同比是-17.3366874753
营业总收入(元)是48684792685.58
营业成本是46392180562.59
AI:
本钢板材在2020年对联营企业和合营企业的投资收益是374119.86元。
现在开始：
人类：{query}
额外信息：该公司的数据如下所示
{extra_information}
AI:
"""
def answer_generation_raw_prompt():
return PromptTemplate(template=PROMPT, input_variables=["extra_information", "query"])
def answer_generation_prompt(extra_information: str, query: str):
P = PromptTemplate(template=PROMPT, input_variables=[
"extra_information", "query"])
return P.format(extra_information=extra_information, query=query)
if __name__ == "__main__":
print(answer_generation_prompt("你们公司的装箱算法可以用在服装业吗")) | [
"\n你需要扮演一位金融专家助手。请根据所提供的额外信息，回答下列问题。请注意，额外信息虽然都是有效的，但你只需使用与问题直接相关的部分。\n\n要求：\n1. 答案应简练、清晰、准确。\n2. 仅使用与问题直接相关的额外信息进行回答。\n3. 避免引入与问题无关的信息。\n\n示例：\n人类：本钢板材在2020年对联营企业和合营企业的投资收益是多少元？\n额外信息：该公司的数据如下所示\n其中:对联营企业和合营企业的投资收益/（损失）是374119.86\n其中:对联营企业和合营企业的投资收益/（损失） 同比是-17.3366874753\n营业总收入(元)是48684792685.58\n营业成本是46392180562.59\nAI:\n本钢板材在2020年对联营企业和合营企业的投资收益是374119.86元。\n\n现在开始：\n\n人类：{query}\n额外信息：该公司的数据如下所示\n{extra_information}\nAI:\n"
] |
2024-01-10 | KylinC/ChatFinance | prompts~relevance_scoring.py | from langchain import PromptTemplate
PROMPT = """
你需要扮演一个优秀的文本相关性评估助手。你需要评估额外信息是否有助于提供更优质和简练的回答。
你不需要做任何解释说明，并且严格按照示例的格式进行输出，仅回答["是", "否"]
以下是一个示例：
人类：我有一个服装厂，是否可以应用你们的装箱算法改善装载率呢？
额外信息：问：能否介绍一下蓝胖子机器智能的主力产品？ 答：蓝胖子机器智能的主力产品是“蓝胖智汇Doraopt”系列AI软件产品及解决方案。这是由我们的AIoT产品事业部打造的，用于提供智能供应链的整体解决方案。
AI:否
现在开始：
人类：{query}
额外信息：{extra_information}
AI:
"""
def relevance_scoring_raw_prompt():
return PromptTemplate(template=PROMPT, input_variables=["query", "extra_information"])
def relevance_scoring_prompt(query: str, extra_information: str):
P = PromptTemplate(template=PROMPT, input_variables=[
"query", "extra_information"])
return P.format(query=query, extra_information=extra_information)
if __name__ == "__main__":
print(relevance_scoring_prompt(
query="你们的装箱算法能不能用在家居业呀？主要用于是沙发的装箱。",
extra_information="问：DoraCLP「装满满」适用于哪些行业？ 答：DoraCLP「装满满」可以广泛应用于多个行业，例如家居业和鞋服业等。"),
)
| [
"\n你需要扮演一个优秀的文本相关性评估助手。你需要评估额外信息是否有助于提供更优质和简练的回答。\n\n你不需要做任何解释说明，并且严格按照示例的格式进行输出，仅回答[\"是\", \"否\"]\n\n以下是一个示例：\n人类：我有一个服装厂，是否可以应用你们的装箱算法改善装载率呢？\n额外信息：问：能否介绍一下蓝胖子机器智能的主力产品？ 答：蓝胖子机器智能的主力产品是“蓝胖智汇Doraopt”系列AI软件产品及解决方案。这是由我们的AIoT产品事业部打造的，用于提供智能供应链的整体解决方案。\nAI:否\n\n现在开始：\n人类：{query}\n额外信息：{extra_information}\nAI:\n"
] |
2024-01-10 | KylinC/ChatFinance | prompts~information_extraction.py | from langchain import PromptTemplate
PROMPT = """
你需要扮演一个优秀的关键信息提取助手，从人类的对话中提取关键性内容（最多5个关键词），以协助其他助手更精准地回答问题。
注意：你不需要做任何解释说明，只需严格按照示例的格式输出关键词。
示例：
人类：我有一个服装厂，是否可以应用你们的装箱算法改善装载率呢？
AI: 服装厂, 装箱算法, 装载率
现在开始：
人类：{query}
AI:
"""
def information_extraction_raw_prompt():
return PromptTemplate(template=PROMPT, input_variables=["query"])
def information_extraction_prompt(query: str):
P = PromptTemplate(template=PROMPT, input_variables=["query"])
return P.format(query=query)
if __name__ == "__main__":
print(information_extraction_prompt("你们的装箱算法能不能用在家居业呀？"))
| [
"\n你需要扮演一个优秀的关键信息提取助手，从人类的对话中提取关键性内容（最多5个关键词），以协助其他助手更精准地回答问题。\n\n注意：你不需要做任何解释说明，只需严格按照示例的格式输出关键词。\n\n示例：\n人类：我有一个服装厂，是否可以应用你们的装箱算法改善装载率呢？\nAI: 服装厂, 装箱算法, 装载率\n\n现在开始：\n人类：{query}\nAI:\n"
] |
2024-01-10 | KylinC/ChatFinance | prompts~intent_recognition.py |
from langchain import PromptTemplate
# 你不需要做任何解释说明，并且严格按照示例的格式进行输出，仅输出["金融常识问题","文本检索问题","数值检索问题"]。
PROMPT = """
你需要扮演一个优秀的意图识别助手，你需要写出思考过程，并判断人类的问题是属于（开放问题/检索问题）类别的一项。
示例一：
人类：判断<能否根据2020年金宇生物技术股份有限公司的年报，给我简要介绍一下报告期内公司的社会责任工作情况？>的类别。
思考：
1. 题目中出现了具体公司名称的关键词 "金宇生物技术股份有限公司"。
2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。
答案: 检索问题
示例二：
人类：判断<2019年四方科技电子信箱是什么>的类别。
思考：
1. 题目中出现了具体公司名称的关键词 "四方科技"。
2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。
答案: 检索问题
示例三：
人类：判断<研发费用对公司的技术创新和竞争优势有何影响？>的类别。
思考：
1. 题目中未出现任何具体公司名称的关键词。
2. 由于题目未包含具体公司名称的关键词，判断该题目属于开放问题。
答案: 开放问题
示例四：
人类：判断<请根据江化微2019年的年报，简要介绍报告期内公司主要销售客户的客户集中度情况，并结合同行业情况进行分析。>的类别。
思考：
1. 题目中出现了具体公司名称的关键词 "江化微"。
2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。
答案: 检索问题
示例五：
人类：判断<康希诺生物股份公司在2020年的资产负债比率具体是多少，需要保留至小数点后两位？>的类别。
思考：
1. 题目中出现了具体公司名称的关键词 "康希诺生物股份公司"。
2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。
答案: 检索问题
示例六：
人类：判断<平潭发展在2021年的投资收益增长率保留到小数点后两位是多少？>的类别。
思考：
1. 题目中出现了具体公司名称的关键词 "平潭发展"。
2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。
答案: 检索问题
注意：
1.你不需要做任何解释说明，并且严格按照上述示例的格式进行输出, 需要包括"思考"和"答案"两部分。
2."思考"仅有"1."和"2."两个步骤，不应该有更多的思考步骤。
现在开始：
人类：判断<{query}>的类别。
"""
def intent_recognition_raw_prompt():
return PromptTemplate(template=PROMPT, input_variables=["query"])
def intent_recognition_prompt(query: str):
P = PromptTemplate(template=PROMPT, input_variables=["query"])
return P.format(query=query)
if __name__ == "__main__":
print(intent_recognition_prompt("博云新材在2020年对联营企业和合营企业的投资收益是多少元？"))
| [
"\n你需要扮演一个优秀的意图识别助手，你需要写出思考过程，并判断人类的问题是属于（开放问题/检索问题）类别的一项。\n\n示例一：\n人类：判断<能否根据2020年金宇生物技术股份有限公司的年报，给我简要介绍一下报告期内公司的社会责任工作情况？>的类别。\n思考：\n1. 题目中出现了具体公司名称的关键词 \"金宇生物技术股份有限公司\"。\n2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。\n答案: 检索问题\n\n示例二：\n人类：判断<2019年四方科技电子信箱是什么>的类别。\n思考：\n1. 题目中出现了具体公司名称的关键词 \"四方科技\"。\n2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。\n答案: 检索问题\n\n示例三：\n人类：判断<研发费用对公司的技术创新和竞争优势有何影响？>的类别。\n思考：\n1. 题目中未出现任何具体公司名称的关键词。\n2. 由于题目未包含具体公司名称的关键词，判断该题目属于开放问题。\n答案: 开放问题\n\n示例四：\n人类：判断<请根据江化微2019年的年报，简要介绍报告期内公司主要销售客户的客户集中度情况，并结合同行业情况进行分析。>的类别。\n思考：\n1. 题目中出现了具体公司名称的关键词 \"江化微\"。\n2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。\n答案: 检索问题\n\n示例五：\n人类：判断<康希诺生物股份公司在2020年的资产负债比率具体是多少，需要保留至小数点后两位？>的类别。\n思考：\n1. 题目中出现了具体公司名称的关键词 \"康希诺生物股份公司\"。\n2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。\n答案: 检索问题\n\n示例六：\n人类：判断<平潭发展在2021年的投资收益增长率保留到小数点后两位是多少？>的类别。\n思考：\n1. 题目中出现了具体公司名称的关键词 \"平潭发展\"。\n2. 由于题目包含具体公司名称的关键词，判断该题目属于检索问题。\n答案: 检索问题\n\n注意：\n 1.你不需要做任何解释说明，并且严格按照上述示例的格式进行输出, 需要包括\"思考\"和\"答案\"两部分。\n 2.\"思考\"仅有\"1.\"和\"2.\"两个步骤，不应该有更多的思考步骤。\n\n现在开始：\n人类：判断<{query}>的类别。\n"
] |
2024-01-10 | KylinC/ChatFinance | prompts~entity_recognition.py | from langchain import PromptTemplate
PROMPT = """
你需要扮演一个优秀的实体提取助手。你的任务是从人类提供的问句中抽取并精确返回公司名称和年份。
示例一：
人类：抽取<请根据2020年金宇生物技术股份有限公司的年报，简述公司的社会责任工作情况。>中的公司名，年份。
公司名：金宇生物技术股份有限公司
年份：2020年
示例二：
人类：抽取<2019年安记食品股份有限公司的营业利润率是多少？结果请保留至小数点后两位。>中的公司名，年份。
公司名：安记食品股份有限公司
年份：2019年
示例三：
人类：抽取<研发费用如何影响公司的技术创新和竞争优势？>中的公司名，年份。
公司名：无
年份：无
示例四：
人类：抽取<平潭发展在2021年的投资收益增长率保留到小数点后两位是多少？>中的公司名，年份。
公司名：平潭发展
年份：2021年
示例五：
人类：抽取<请根据江化微2019年的年报，简要介绍报告期内公司主要销售客户的客户集中度情况，并结合同行业情况进行分析。>中的公司名，年份。
公司名：江化微
年份：2019年
注意：
1.你不需要做任何解释说明，并且严格按照上述示例的格式进行输出。
2.如果信息未包含对应实体，请输出"无"。
3.你不要把信息中<...>的内容当作问题回答，它是作为被实体提取的对象。
4.你的回答仅包括"公司名"和"年份"两个部分，年份请输出20xx年，请避免输出无关的信息。
现在开始：
人类：抽取<{query}>中的公司名，年份。
"""
def entity_recognition_raw_prompt():
return PromptTemplate(template=PROMPT, input_variables=["query"])
def entity_recognition_prompt(query: str):
P = PromptTemplate(template=PROMPT, input_variables=["query"])
return P.format(query=query)
if __name__ == "__main__":
print(entity_recognition_prompt("你们的装箱算法能不能用在家居业呀？主要用于是沙发的装箱。"))
| [
"\n你需要扮演一个优秀的实体提取助手。你的任务是从人类提供的问句中抽取并精确返回公司名称和年份。\n\n示例一：\n人类：抽取<请根据2020年金宇生物技术股份有限公司的年报，简述公司的社会责任工作情况。>中的公司名，年份。\n公司名：金宇生物技术股份有限公司\n年份：2020年\n\n示例二：\n人类：抽取<2019年安记食品股份有限公司的营业利润率是多少？结果请保留至小数点后两位。>中的公司名，年份。\n公司名：安记食品股份有限公司 \n年份：2019年\n\n示例三：\n人类：抽取<研发费用如何影响公司的技术创新和竞争优势？>中的公司名，年份。\n公司名：无 \n年份：无 \n\n示例四：\n人类：抽取<平潭发展在2021年的投资收益增长率保留到小数点后两位是多少？>中的公司名，年份。\n公司名：平潭发展\n年份：2021年\n\n示例五：\n人类：抽取<请根据江化微2019年的年报，简要介绍报告期内公司主要销售客户的客户集中度情况，并结合同行业情况进行分析。>中的公司名，年份。\n公司名：江化微\n年份：2019年\n\n注意：\n 1.你不需要做任何解释说明，并且严格按照上述示例的格式进行输出。\n 2.如果信息未包含对应实体，请输出\"无\"。\n 3.你不要把信息中<...>的内容当作问题回答，它是作为被实体提取的对象。\n 4.你的回答仅包括\"公司名\"和\"年份\"两个部分，年份请输出20xx年，请避免输出无关的信息。\n\n\n现在开始：\n人类：抽取<{query}>中的公司名，年份。\n"
] |
2024-01-10 | KylinC/ChatFinance | database_server~weaviate~scripts~connection.py | # import sys # noqa: E501
# sys.path.append('/home/shadowmotion/Documents/code/demo/HRSSC') # noqa: E501
from langchain.vectorstores import Weaviate
from utils import JinaEmbeddings
from jina import Document
import weaviate
def read_qa_file(file_path):
with open(file_path, "r", encoding='utf-8') as f:
lines = f.readlines()
qa_list = []
question, answer = None, None
for line in lines:
line = line.strip() # remove leading/trailing whitespaces
if line.startswith("问："):
# save the previous qa pair if it exists
if question and answer:
qa_list.append(f"{question} {answer}")
# start a new qa pair
question = line
answer = None
elif line.startswith("答："):
answer = line
# don't forget the last qa pair
if question and answer:
qa_list.append(f"{question} {answer}")
return qa_list
client = weaviate.Client(
url="http://localhost:8080", # Replace with your endpoint
auth_client_secret=weaviate.AuthApiKey(api_key="shadowmotion-secret-key"))
embedding = JinaEmbeddings("127.0.0.1")
db = Weaviate(client=client, embedding=embedding,
index_name="LangChain", text_key="text", by_text=False)
# print(embedding.embed_documents(read_qa_file("raw/QA.txt")))
db.add_texts(texts=read_qa_file("./QA.txt"))
# db.add_documents(
# [Document(page_content="1", metadata={"Q": "1+1=", "A": "2"})]
# )
| [] |
2024-01-10 | KylinC/ChatFinance | prompts~open_question.py | from langchain import PromptTemplate
PROMPT = """
你需要扮演一位金融专家助手。请根据你的专业知识，回答下列问题。
要求：
1. 答案应简练、清晰、准确。
2. 仅使用与问题直接相关的额外信息进行回答。
3. 避免引入与问题无关的信息。
示例一：
人类：什么是价值投资？
AI: 价值投资是投资策略的一种，由班杰明·葛拉汉和大卫·多德（英语：DavidDodd）所提出。和价值投资法所对应的是成长投资法。其重点是透过基本面分析中的概念，例如高股息收益率、低市盈率（P/E，股价/每股净利润）和低市净率（P/B，股价/每股净资产），去寻找并投资于一些股价被低估的股票。
示例二：
人类：什么是营业利润？
AI: 营业利润（英语：OperatingIncome、OperatingProfit）或译营业利益是营业收入减除营业成本及营业费用后之余额。其为正数，表示本期营业盈余之数；其为负数，表示本期营业亏损之数。当一间公司没有营业外收入与营业外支出，有时营业利润与息税前利润被当作同义词。
示例：
人类：什么是营业税金及附加？
AI: 营业税金及附加是指对企业或个人因经营活动所产生的收入或销售额征收的税费，以及可能与之相关的其他费用或附加费。
现在开始：
人类：{query}
AI:
"""
def open_question_prompt(query: str):
P = PromptTemplate(template=PROMPT, input_variables=["query"])
return P.format(query=query)
if __name__ == "__main__":
print(open_question_prompt("什么是营业额？")) | [
"\n你需要扮演一位金融专家助手。请根据你的专业知识，回答下列问题。\n\n要求：\n1. 答案应简练、清晰、准确。\n2. 仅使用与问题直接相关的额外信息进行回答。\n3. 避免引入与问题无关的信息。\n\n示例一：\n人类：什么是价值投资？\nAI: 价值投资是投资策略的一种，由班杰明·葛拉汉和大卫·多德（英语：DavidDodd）所提出。和价值投资法所对应的是成长投资法。其重点是透过基本面分析中的概念，例如高股息收益率、低市盈率（P/E，股价/每股净利润）和低市净率（P/B，股价/每股净资产），去寻找并投资于一些股价被低估的股票。\n\n示例二：\n人类：什么是营业利润？\nAI: 营业利润（英语：OperatingIncome、OperatingProfit）或译营业利益是营业收入减除营业成本及营业费用后之余额。其为正数，表示本期营业盈余之数；其为负数，表示本期营业亏损之数。当一间公司没有营业外收入与营业外支出，有时营业利润与息税前利润被当作同义词。\n\n示例：\n人类：什么是营业税金及附加？\nAI: 营业税金及附加是指对企业或个人因经营活动所产生的收入或销售额征收的税费，以及可能与之相关的其他费用或附加费。\n\n现在开始：\n\n人类：{query}\nAI:\n"
] |
2024-01-10 | phil329/lawgpt | utils~iflytek~ifly_spark.py | # -*- coding: utf-8 -*-
import openai
import json
def Spark(query, model='gpt-3.5-turbo'):
try:
openai.api_key = 'your api key'
openai.proxy = {'http': '127.0.0.1:7890', 'https': '127.0.0.1:7890'}
# openai.proxy = {'http': '124.70.203.196:20171', 'https': '124.70.203.196:20171'}
messages = [
{"role": "user", "content": query},
]
print(model)
print(messages)
response = openai.ChatCompletion.create(model=model, messages=messages,temperature=0)
answer = response.choices[0].message.content
answer = json.dumps(answer, ensure_ascii=False)
return answer
except Exception as e:
print('报错：',str(e))
if __name__ == '__main__':
query = '你是谁'
res = Spark(query)
print(res) | [
"你是谁"
] |
2024-01-10 | KeriYuu/ChatGPT-Driven-Shopping-Assistant | src~retriever.py | from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema import Document
from langchain.chat_models import ChatOpenAI
from utils import read_funcs
import json
import tools
from langchain.schema import (
AIMessage,
HumanMessage,
SystemMessage
)
class Retriever:
def __init__(self, debug=False, max_tools=10):
self.All_tools = []
self.max_tools = max_tools
self.llm = ChatOpenAI(temperature=0)
self.debug = debug
search_apis = read_funcs("tools.py")
for name in search_apis:
self.All_tools.append(getattr(tools, name))
docs = [Document(page_content=t.description, metadata={"index": i}) for i, t in enumerate(self.All_tools)]
vector_store = FAISS.from_documents(docs, OpenAIEmbeddings())
self.retriever = vector_store.as_retriever(k=self.max_tools)
def get_tools(self, query):
messages = []
with open("prompts/prompting.json", "r") as f:
data = json.load(f)['paraphrase']
messages.append(SystemMessage(content=data["system"]))
messages.append(AIMessage(content=data["input"]))
messages.append(HumanMessage(content=data["output"]))
messages.append(HumanMessage(content=query))
paraphrase = self.llm(messages).content
docs = self.retriever.get_relevant_documents(query + "\n" + paraphrase)
tools = [self.All_tools[d.metadata["index"]] for d in docs]
return tools
| [
"input"
] |
2024-01-10 | CookieJaySJ/nastool3 | app~plugins~modules~_autosignin~chdbits.py | import json
import os
import random
import re
from lxml import etree
from app.helper.openai_helper import OpenAiHelper
from app.plugins.modules._autosignin._base import _ISiteSigninHandler
from app.utils import StringUtils, RequestUtils
from config import Config
class CHDBits(_ISiteSigninHandler):
"""
彩虹岛签到
如果填写openai key则调用chatgpt获取答案
否则随机
"""
# 匹配的站点Url，每一个实现类都需要设置为自己的站点Url
site_url = "chdbits.co"
# 已签到
_sign_regex = ['今天已经签过到了']
# 签到成功，待补充
_success_regex = ['\\d+点魔力值']
# 存储正确的答案，后续可直接查
_answer_path = os.path.join(Config().get_temp_path(), "signin")
_answer_file = _answer_path + "/chdbits.json"
@classmethod
def match(cls, url):
"""
根据站点Url判断是否匹配当前站点签到类，大部分情况使用默认实现即可
:param url: 站点Url
:return: 是否匹配，如匹配则会调用该类的signin方法
"""
return True if StringUtils.url_equal(url, cls.site_url) else False
def signin(self, site_info: dict):
"""
执行签到操作
:param site_info: 站点信息，含有站点Url、站点Cookie、UA等信息
:return: 签到结果信息
"""
site = site_info.get("name")
site_cookie = site_info.get("cookie")
ua = site_info.get("ua")
proxy = Config().get_proxies() if site_info.get("proxy") else None
# 创建正确答案存储目录
if not os.path.exists(os.path.dirname(self._answer_file)):
os.makedirs(os.path.dirname(self._answer_file))
# 判断今日是否已签到
index_res = RequestUtils(cookies=site_cookie,
headers=ua,
proxies=proxy
).get_res(url='https://chdbits.co/bakatest.php')
if not index_res or index_res.status_code != 200:
self.error(f"签到失败，请检查站点连通性")
return False, f'【{site}】签到失败，请检查站点连通性'
if "login.php" in index_res.text:
self.error(f"签到失败，cookie失效")
return False, f'【{site}】签到失败，cookie失效'
sign_status = self.sign_in_result(html_res=index_res.text,
regexs=self._sign_regex)
if sign_status:
self.info(f"今日已签到")
return True, f'【{site}】今日已签到'
# 没有签到则解析html
html = etree.HTML(index_res.text)
if not html:
return False, f'【{site}】签到失败'
# 获取页面问题、答案
questionid = html.xpath("//input[@name='questionid']/@value")[0]
option_ids = html.xpath("//input[@name='choice[]']/@value")
option_values = html.xpath("//input[@name='choice[]']/following-sibling::text()")
question_str = html.xpath("//td[@class='text' and contains(text(),'请问：')]/text()")[0]
answers = list(zip(option_ids, option_values))
# 正则获取问题
match = re.search(r'请问：(.+)', question_str)
if match:
question_str = match.group(1)
self.debug(f"获取到签到问题 {question_str}")
else:
self.error(f"未获取到签到问题")
return False, f"【{site}】签到失败，未获取到签到问题"
# 查询已有答案
exits_answers = {}
try:
with open(self._answer_file, 'r') as f:
json_str = f.read()
exits_answers = json.loads(json_str)
# 查询本地本次验证码hash答案
question_answer = exits_answers[question_str]
# question_answer是数组
if not isinstance(question_answer, list):
question_answer = [question_answer]
# 本地存在本次hash对应的正确答案再遍历查询
choice = []
for q in question_answer:
for num, answer in answers:
if str(q) == str(num):
choice.append(int(q))
if len(choice) > 0:
# 签到
return self.__signin(questionid=questionid,
choice=choice,
site_cookie=site_cookie,
ua=ua,
proxy=proxy,
site=site)
except (FileNotFoundError, IOError, OSError) as e:
self.debug("查询本地已知答案失败，继续请求豆瓣查询")
# 正确答案，默认随机，如果gpt返回则用gpt返回的答案提交
choice = [option_ids[random.randint(0, len(option_ids) - 1)]]
# 组装gpt问题
gpt_options = "{\n" + ",\n".join([f"{num}:{value}" for num, value in answers]) + "\n}"
gpt_question = f"题目：{question_str}\n" \
f"选项：{gpt_options}"
self.debug(f"组装chatgpt问题 {gpt_question}")
# chatgpt获取答案
answer = OpenAiHelper().get_question_answer(question=gpt_question)
self.debug(f"chatpgt返回结果 {answer}")
# 处理chatgpt返回的答案信息
if answer is None:
self.warn(f"ChatGPT未启用, 开始随机签到")
# return f"【{site}】签到失败，ChatGPT未启用"
elif answer:
# 正则获取字符串中的数字
answer_nums = list(map(int, re.findall("\d+", answer)))
if not answer_nums:
self.warn(f"无法从chatgpt回复 {answer} 中获取答案, 将采用随机签到")
else:
choice = []
for answer in answer_nums:
# 如果返回的数字在option_ids范围内，则直接作为答案
if str(answer) in option_ids:
choice.append(int(answer))
self.info(f"chatgpt返回答案id {answer} 在签到选项 {option_ids} 中")
# 签到
return self.__signin(questionid=questionid,
choice=choice,
site_cookie=site_cookie,
ua=ua,
proxy=proxy,
site=site,
exits_answers=exits_answers,
question=question_str)
def __signin(self, questionid, choice, site, site_cookie, ua, proxy, exits_answers=None, question=None):
"""
签到请求
questionid: 450
choice[]: 8
choice[]: 4
usercomment: 此刻心情:无
submit: 提交
多选会有多个choice[]....
"""
data = {
'questionid': questionid,
'choice[]': choice[0] if len(choice) == 1 else choice,
'usercomment': '太难了！',
'wantskip': '不会'
}
self.debug(f"签到请求参数 {data}")
sign_res = RequestUtils(cookies=site_cookie,
headers=ua,
proxies=proxy
).post_res(url='https://chdbits.co/bakatest.php', data=data)
if not sign_res or sign_res.status_code != 200:
self.error(f"签到失败，签到接口请求失败")
return False, f'【{site}】签到失败，签到接口请求失败'
# 判断是否签到成功
sign_status = self.sign_in_result(html_res=sign_res.text,
regexs=self._success_regex)
if sign_status:
self.info(f"签到成功")
if exits_answers and question:
# 签到成功写入本地文件
self.__write_local_answer(exits_answers=exits_answers or {},
question=question,
answer=choice)
return True, f'【{site}】签到成功'
else:
sign_status = self.sign_in_result(html_res=sign_res.text,
regexs=self._sign_regex)
if sign_status:
self.info(f"今日已签到")
return True, f'【{site}】今日已签到'
self.error(f"签到失败，请到页面查看")
return False, f'【{site}】签到失败，请到页面查看'
def __write_local_answer(self, exits_answers, question, answer):
"""
签到成功写入本地文件
"""
try:
exits_answers[question] = answer
# 序列化数据
formatted_data = json.dumps(exits_answers, indent=4)
with open(self._answer_file, 'w') as f:
f.write(formatted_data)
except (FileNotFoundError, IOError, OSError) as e:
self.debug("签到成功写入本地文件失败")
| [] |
2024-01-10 | shivance/keras-nlp | keras_nlp~tokenizers~byte_pair_tokenizer.py | # Copyright 2023 The KerasNLP Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Byte-pair encoder implementation.
This file implements the same logic as openai BPE:
https://github.com/openai/gpt-2/blob/master/src/encoder.py,
but is TF graph compatible.
"""
import json
import os
from typing import Iterable
from typing import List
import regex as re
import tensorflow as tf
from keras_nlp.api_export import keras_nlp_export
from keras_nlp.backend import keras
from keras_nlp.tokenizers import tokenizer
from keras_nlp.utils.python_utils import classproperty
from keras_nlp.utils.python_utils import format_docstring
from keras_nlp.utils.tensor_utils import assert_tf_text_installed
from keras_nlp.utils.tensor_utils import convert_to_ragged_batch
from keras_nlp.utils.tensor_utils import is_integer_dtype
from keras_nlp.utils.tensor_utils import is_string_dtype
try:
import tensorflow_text as tf_text
except ImportError:
tf_text = None
# As python and TF handles special spaces differently, we need to
# manually handle special spaces during string split.
SPECIAL_WHITESPACES = r"\x{a0}\x{2009}\x{202f}\x{3000}"
# String splitting regex pattern.
SPLIT_PATTERN_1 = (
r"'s|'t|'re|'ve|'m|'ll|'d"
+ r"|[\s{special_spaces}]+[\n\r\t\f६{special_spaces}]| ?\p{L}+|"
+ r" ?[\p{N}]+| ?[^\s\p{L}\p{N}{special_spaces}]+"
)
SPLIT_PATTERN_1 = SPLIT_PATTERN_1.replace(
"{special_spaces}", SPECIAL_WHITESPACES
)
SPLIT_PATTERN_2 = rf"""[\s६{SPECIAL_WHITESPACES}]$"""
def create_alts_for_unsplittable_tokens(unsplittable_tokens):
# Create alternates for all special tokens that will be not split during
# tokenization.
alts = []
prefix = "Ĵ"
# Trim out splitters.
replace_pattern = r"'|\s+|[^\p{L}\p{N}]+"
for token in unsplittable_tokens:
token = re.sub(replace_pattern, "", token)
alts.append(prefix + token)
return alts
def bytes_to_unicode():
bs = (
list(range(ord("!"), ord("~") + 1))
+ list(range(ord("¡"), ord("¬") + 1))
+ list(range(ord("®"), ord("ÿ") + 1))
)
cs = bs[:]
n = 0
# removes mapping an int to a whitespace character
for b in range(2**8):
if b not in bs:
bs.append(b)
cs.append(2**8 + n)
n += 1
cs = [chr(n) for n in cs]
bs = [n.to_bytes(1, "little") for n in bs]
return bs, cs # int to string mapping
def remove_strings_from_inputs(tensor, string_to_remove):
"""Remove certain strings from input tensor."""
non_empty_mask = tensor != string_to_remove
flatten_indexes = tf.where(non_empty_mask)
flatten_result = tf.gather_nd(tensor, flatten_indexes)
row_lengths = tf.reduce_sum(tf.cast(non_empty_mask, "int64"), axis=1)
result = tf.RaggedTensor.from_row_lengths(
values=flatten_result,
row_lengths=row_lengths,
)
return result
def split_strings_for_bpe(inputs, unsplittable_tokens=None):
# We need to recreate the exact behavior of token presplitting in the
# original gpt2 tokenizer which uses a lookahead. As re2 does not
# support lookahead match, we are using an alternative insert a special
# token "६" before leading space of non-space characters and after the
# trailing space, e.g., " keras" will be "६ keras".
inputs = tf.strings.regex_replace(
inputs, rf"( )([^\s{SPECIAL_WHITESPACES}])", r"६\1\2"
)
inputs = tf.strings.regex_replace(
inputs, rf"(\s{SPECIAL_WHITESPACES})$", r"\1६"
)
if unsplittable_tokens:
alts = create_alts_for_unsplittable_tokens(unsplittable_tokens)
for token, alt in zip(unsplittable_tokens, alts):
escaped_token = re.escape(token)
inputs = tf_text.regex_split(inputs, escaped_token, escaped_token)
inputs = tf.strings.regex_replace(inputs, escaped_token, alt)
raw_tokens = tf_text.regex_split(inputs, SPLIT_PATTERN_1, SPLIT_PATTERN_1)
# Second pass splits out the last whilespace char or "६".
raw_tokens = tf_text.regex_split(
raw_tokens, SPLIT_PATTERN_2, SPLIT_PATTERN_2
)
if unsplittable_tokens:
# Replace special tokens alternate with originals.
for token, alt in zip(unsplittable_tokens, alts):
escaped_alt = re.escape(alt)
raw_tokens = tf.strings.regex_replace(
raw_tokens, escaped_alt, token
)
while raw_tokens.shape.rank > 2:
raw_tokens = raw_tokens.merge_dims(1, 2)
return remove_strings_from_inputs(raw_tokens, "६")
class BytePairTokenizerCache(tf.Module):
"""Cache that stores the encoded result of seen tokens.
The cache key is string tensor or python strings, and the value is split
tokens joined by whitespace. For example, "dragonfly" => "dragon fly"
Examples:
```
cache = BytePairTokenizerCache()
cache.insert(["butterfly", "dragonfly"], ["but ter fly", "dragon fly"])
cache.lookup(["butterfly"])
```
"""
def __init__(self):
# `tf.lookup.experimental.MutableHashTable` does not support string to
# string mapping. So we first convert to string to an integer key, and
# use the integer key to find the value.
self.factors = tf.pow(
tf.constant(256, dtype="int64"), tf.range(0, 8, dtype="int64")
)
self.id2value = tf.lookup.experimental.MutableHashTable(
"int64", tf.string, ""
)
def _get_key(self, keys):
"""Get the hash key for given inputs."""
# `tf.fingerprint` converts token to a array of uint8 of length 8, we
# need to convert it to a uint64.
return tf.squeeze(
tf.matmul(
tf.cast(tf.fingerprint(keys), dtype="int64"),
self.factors[:, tf.newaxis],
),
-1,
)
def lookup(self, keys):
"""Look up the encoded outputs of given tokens."""
ids = self._get_key(keys)
result = self.id2value.lookup(ids)
# Ensure output shape for graph mode.
result.set_shape([None])
return result
def insert(self, keys, values):
"""Insert token <=> encoded outputs pairs."""
self.id2value.insert(self._get_key(keys), values)
def create_static_hashtable(keys, values, default):
return tf.lookup.StaticHashTable(
tf.lookup.KeyValueTensorInitializer(
tf.convert_to_tensor(keys),
tf.convert_to_tensor(values),
),
default_value=default,
)
@keras_nlp_export("keras_nlp.tokenizers.BytePairTokenizer")
class BytePairTokenizer(tokenizer.Tokenizer):
"""Bype-pair encoding tokenizer layer.
This BPE tokenizer provides the same functionality as the official GPT-2
tokenizer. Given the same `vocabulary` which maps tokens to ids, and `merges`
which describes BPE merge rules, it should provide the same output
as OpenAI implementation (https://github.com/openai/gpt-2/blob/master/src/encoder.py).
Different from OpenAI, this implementation is graph-compatible, so you can
use it within a `tf.data` pipeline.
If input is a batch of strings (rank > 0):
By default, the layer will output a `tf.RaggedTensor` where the last
dimension of the output is ragged. If `sequence_length` is set, the layer
will output a dense `tf.Tensor` where all inputs have been padded or
truncated to `sequence_length`.
If input is a scalar string (rank == 0):
By default, the layer will output a dense `tf.Tensor` with static shape
`[None]`. If `sequence_length` is set, the output will be
a dense `tf.Tensor` of shape `[sequence_length]`.
Args:
vocabulary: string or dict, maps token to integer ids. If it is a
string, it should be the file path to a json file.
merges: string or list, contains the merge rule. If it is a string,
it should be the file path to merge rules. The merge rule file
should have one merge rule per line.
sequence_length: int. If set, the output will be
padded or truncated to the `sequence_length`. Defaults to `None`.
add_prefix_space: bool. Whether to add an
initial space to the input. This tokenizer is whitespace aware,
and will tokenize a word with a leading space differently. Adding
a prefix space to the first word will cause it to be tokenized
equivalently to all subsequent words in the sequence.
Defaults to `False`.
unsplittable_tokens: list. A list of strings that will
never be split during the word-level splitting applied before the
byte-pair encoding. This can be used to ensure special tokens map to
unique indices in the vocabulary, even if these special tokens
contain splittable characters such as punctuation. Special tokens
must still be included in `vocabulary`. Defaults to `None`.
Examples:
Tokenize
>>> vocab = {"butter": 1, "fly": 2}
>>> merge = ["b u", "t t", "e r", "bu tt", "butt er", "f l", "fl y"]
>>> tokenizer = keras_nlp.tokenizers.BytePairTokenizer(vocab, merge)
>>> outputs = tokenizer("butterfly")
>>> np.array(outputs)
array([1, 2], dtype=int32)
>>> seq1, seq2 = tokenizer(["butterfly", "butter"])
>>> np.array(seq1)
array([1, 2], dtype=int32)
>>> np.array(seq2)
array([1], dtype=int32)
>>> tokenizer = keras_nlp.tokenizers.BytePairTokenizer(
... vocab, merge, sequence_length=2)
>>> seq1, seq2 = tokenizer(["butterfly", "butter"])
>>> np.array(seq1)
array([1, 2], dtype=int32)
>>> np.array(seq2)
array([1, 0], dtype=int32)
Detokenize
>>> vocab = {"butter": 1, "fly": 2}
>>> merge = ["b u", "t t", "e r", "bu tt", "butt er", "f l", "fl y"]
>>> tokenizer = keras_nlp.tokenizers.BytePairTokenizer(vocab, merge)
>>> tokenizer.detokenize([[1, 2]])
<tf.Tensor: shape=(1,), dtype=string, numpy=array([b'butterfly'],
dtype=object)>
"""
def __init__(
self,
vocabulary,
merges,
sequence_length=None,
add_prefix_space=False,
unsplittable_tokens=None,
dtype="int32",
**kwargs,
) -> None:
assert_tf_text_installed(self.__class__.__name__)
if not is_integer_dtype(dtype) and not is_string_dtype(dtype):
raise ValueError(
"Output dtype must be an integer type or a string. "
f"Received: dtype={dtype}"
)
super().__init__(dtype=dtype, **kwargs)
if isinstance(vocabulary, str):
with open(vocabulary, "r") as f:
self.vocabulary = json.load(f)
elif isinstance(vocabulary, dict):
self.vocabulary = vocabulary.copy()
else:
raise ValueError(
"Vocabulary must be an file path or dictionary mapping string "
"token to int ids. Received: "
f"`type(vocabulary)={type(vocabulary)}`."
)
if isinstance(merges, str):
self.merges = [bp.rstrip() for bp in tf.io.gfile.GFile(merges)]
elif isinstance(merges, Iterable):
self.merges = list(merges)
else:
raise ValueError(
"Merges must be a file path or a list of merge rules. "
f"Received: `type(merges)={type(merges)}`"
)
self.sequence_length = sequence_length
self.add_prefix_space = add_prefix_space
self.unsplittable_tokens = unsplittable_tokens
# Create byte <=> unicode mapping. This is useful for handling
# whitespace tokens.
byte_list, unicode_list = bytes_to_unicode()
self.byte2unicode = create_static_hashtable(
byte_list, unicode_list, default=""
)
self.unicode2byte = create_static_hashtable(
unicode_list, byte_list, default=""
)
self.cache = BytePairTokenizerCache()
if unsplittable_tokens:
# Put special tokens into cache, so it won't be further split and
# merged.
self.cache.insert(unsplittable_tokens, unsplittable_tokens)
# Create mapping between string tokens to int ids, and vice versa.
byte_pairs = [x[0] for x in self.vocabulary.items()]
byte_pair_encoding_indices = [x[1] for x in self.vocabulary.items()]
self.token_to_id_map = create_static_hashtable(
byte_pairs,
byte_pair_encoding_indices,
default=-1,
)
self.id_to_token_map = create_static_hashtable(
byte_pair_encoding_indices,
byte_pairs,
default="",
)
# Create ranking of merge rules, this is the same as order of merge
# pairs in `self.merges`.
self.merge_ranks_lookup_default = len(self.merges) + 1
self.merge_ranks = create_static_hashtable(
self.merges,
list(range(len(self.merges))),
default=self.merge_ranks_lookup_default,
)
def get_vocabulary(self) -> List[str]:
"""Get the tokenizer vocabulary as a list of strings tokens."""
return self.vocabulary.keys()
def vocabulary_size(self) -> int:
"""Get the size of the tokenizer vocabulary."""
return len(self.vocabulary)
def id_to_token(self, id: int) -> str:
"""Convert an integer id to a string token."""
# This will be slow, but keep memory usage down compared to building a
# dict. Assuming the main use case is looking up a few special tokens
# early in the vocab, this should be fine.
keys = self.get_vocabulary()
for token in keys:
if self.vocabulary[token] == id:
return token
raise ValueError(f"`id` is out of the vocabulary. Received: {id}")
def token_to_id(self, token: str) -> int:
"""Convert a string token to an integer id."""
return self.vocabulary[token]
def get_config(self):
config = super().get_config()
config.update(
{
# Ideally vocabulary and merge list would be saved as plain text
# assets in the saved model. We have no good way to support
# this currently, so we save the vocabulary in the config.
"vocabulary": self.vocabulary,
"merges": self.merges,
"sequence_length": self.sequence_length,
"add_prefix_space": self.add_prefix_space,
"unsplittable_tokens": self.unsplittable_tokens,
}
)
return config
@tf.function
def _bpe_merge_one_step(self, words, mask):
"""Perform one step of byte-pair merge."""
# Get all word pairs.
first, second = words[:, :-1], words[:, 1:]
# Mask empty.
non_empty_mask = second.nested_row_lengths()[0] != 0
mask = mask & non_empty_mask
if not tf.reduce_any(mask):
return [words, mask]
non_empty_indices = tf.boolean_mask(tf.range(tf.shape(mask)[0]), mask)
filterd_first = tf.ragged.boolean_mask(first, mask)
filtered_second = tf.ragged.boolean_mask(second, mask)
# Get byte pair ranking in merge rules.
pairs = tf.strings.join([filterd_first, filtered_second], separator=" ")
pair_rank = self.merge_ranks.lookup(pairs)
# Get BPE pair ranks.
min_pair_rank = tf.reduce_min(pair_rank, axis=1)
pair_found_mask = min_pair_rank != self.merge_ranks_lookup_default
# Tokens that cannot be further merged are marked as finished.
mask = tf.tensor_scatter_nd_update(
mask, tf.expand_dims(non_empty_indices, axis=1), pair_found_mask
)
if not tf.math.reduce_any(mask):
return [words, mask]
masked_pair_rank = tf.ragged.boolean_mask(pair_rank, pair_found_mask)
min_pair_rank_indices = tf.math.argmin(
masked_pair_rank.to_tensor(self.merge_ranks_lookup_default), axis=1
)
# Get words and pairs to process.
unfinished_words = tf.ragged.boolean_mask(words, mask)
pair_left = tf.gather(
unfinished_words, min_pair_rank_indices, batch_dims=1
)
pair_right = tf.gather(
unfinished_words, min_pair_rank_indices + 1, batch_dims=1
)
merged_pairs = tf.strings.join([pair_left, pair_right])
empty_strs = tf.fill(tf.shape(merged_pairs), "")
unfinished_word_indices = tf.cast(
tf.boolean_mask(tf.range(tf.shape(mask)[0]), mask), dtype="int64"
)
merged_pair_indices = tf.concat(
[
unfinished_word_indices[:, tf.newaxis],
min_pair_rank_indices[:, tf.newaxis],
],
axis=1,
)
empty_string_indices = tf.concat(
[
unfinished_word_indices[:, tf.newaxis],
min_pair_rank_indices[:, tf.newaxis] + 1,
],
axis=1,
)
tensor_words = words.to_tensor(default_value="")
tensor_words = tf.tensor_scatter_nd_update(
tensor_words,
merged_pair_indices,
merged_pairs,
)
words = tf.tensor_scatter_nd_update(
tensor_words,
empty_string_indices,
empty_strs,
)
# Remove empty strings.
words = remove_strings_from_inputs(words, "")
return [words, mask]
def _bpe_merge(self, inputs):
"""Perform byte-pair merge for each word in the inputs."""
num_words = tf.shape(inputs)[0]
# Merge bytes.
def loop_condition(_, mask):
return tf.math.reduce_any(mask)
initial_mask = tf.fill((num_words,), True)
merged_words, _ = tf.while_loop(
loop_condition,
self._bpe_merge_one_step,
loop_vars=[
inputs,
initial_mask,
],
shape_invariants=[
tf.TensorShape([None, None]),
tf.TensorShape([None]),
],
)
return merged_words
def tokenize(self, inputs):
if not isinstance(inputs, (tf.Tensor, tf.RaggedTensor)):
inputs = tf.convert_to_tensor(inputs)
if self.add_prefix_space:
inputs = tf.strings.join([" ", inputs])
scalar_input = inputs.shape.rank == 0
if scalar_input:
inputs = tf.expand_dims(inputs, 0)
raw_tokens = split_strings_for_bpe(inputs, self.unsplittable_tokens)
token_row_splits = raw_tokens.row_splits
flat_tokens = raw_tokens.flat_values
# Check cache.
cache_lookup = self.cache.lookup(flat_tokens)
cache_mask = cache_lookup == ""
has_unseen_words = tf.math.reduce_any(
(cache_lookup == "") & (flat_tokens != "")
)
def process_unseen_tokens():
unseen_tokens = tf.boolean_mask(flat_tokens, cache_mask)
self._bpe_merge_and_update_cache(unseen_tokens)
return self.cache.lookup(flat_tokens)
# If `has_unseen_words == True`, it means not all tokens are in cache,
# we will process the unseen tokens. Otherwise return the cache lookup.
tokenized_words = tf.cond(
has_unseen_words,
process_unseen_tokens,
lambda: cache_lookup,
)
tokens = tf.strings.split(tokenized_words, sep=" ")
if self.compute_dtype != tf.string:
# Encode merged tokens.
tokens = self.token_to_id_map.lookup(tokens)
# Unflatten to match input.
tokens = tf.RaggedTensor.from_row_splits(
tokens.flat_values,
tf.gather(tokens.row_splits, token_row_splits),
)
# Convert to a dense output if `sequence_length` is set.
if self.sequence_length:
output_shape = tokens.shape.as_list()
output_shape[-1] = self.sequence_length
tokens = tokens.to_tensor(shape=output_shape)
# Convert to a dense output if input in scalar
if scalar_input:
tokens = tf.squeeze(tokens, 0)
tf.ensure_shape(tokens, shape=[self.sequence_length])
return tokens
def detokenize(self, inputs):
inputs, unbatched, _ = convert_to_ragged_batch(inputs)
unicode_text = tf.strings.reduce_join(
self.id_to_token_map.lookup(inputs), axis=-1
)
split_unicode_text = tf.strings.unicode_split(unicode_text, "UTF-8")
outputs = tf.strings.reduce_join(
self.unicode2byte.lookup(split_unicode_text), axis=-1
)
if unbatched:
outputs = tf.squeeze(outputs, 0)
return outputs
def _transform_bytes(self, tokens):
"""Map token bytes to unicode using `byte2unicode`."""
split_bytes = tf.strings.bytes_split(tokens)
split_unicode = self.byte2unicode.lookup(split_bytes)
return split_unicode
def _bpe_merge_and_update_cache(self, tokens):
"""Process unseen tokens and add to cache."""
words = self._transform_bytes(tokens)
tokenized_words = self._bpe_merge(words)
# For each word, join all its token by a whitespace,
# e.g., ["dragon", "fly"] => "dragon fly" for hash purpose.
tokenized_words = tf.strings.reduce_join(
tokenized_words, axis=1, separator=" "
)
self.cache.insert(tokens, tokenized_words)
@classproperty
def presets(cls):
return {}
@classmethod
def from_preset(
cls,
preset,
**kwargs,
):
"""Instantiate {{model_name}} tokenizer from preset vocabulary.
Args:
preset: string. Must be one of "{{preset_names}}".
Examples:
```python
# Load a preset tokenizer.
tokenizer = {{model_name}}.from_preset("{{example_preset_name}}")
# Tokenize some input.
tokenizer("The quick brown fox tripped.")
# Detokenize some input.
tokenizer.detokenize([5, 6, 7, 8, 9])
```
"""
if not cls.presets:
raise NotImplementedError(
"No presets have been created for this class"
)
if preset not in cls.presets:
raise ValueError(
"`preset` must be one of "
f"""{", ".join(cls.presets)}. Received: {preset}."""
)
metadata = cls.presets[preset]
vocabulary = keras.utils.get_file(
"vocab.json",
metadata["vocabulary_url"],
cache_subdir=os.path.join("models", preset),
file_hash=metadata["vocabulary_hash"],
)
merges = keras.utils.get_file(
"merges.txt",
metadata["merges_url"],
cache_subdir=os.path.join("models", preset),
file_hash=metadata["merges_hash"],
)
config = metadata["preprocessor_config"]
config.update(
{
"vocabulary": vocabulary,
"merges": merges,
},
)
return cls.from_config({**config, **kwargs})
def __init_subclass__(cls, **kwargs):
# Use __init_subclass__ to setup a correct docstring for from_preset.
super().__init_subclass__(**kwargs)
# If the subclass does not define from_preset, assign a wrapper so that
# each class can have a distinct docstring.
if "from_preset" not in cls.__dict__:
def from_preset(calling_cls, *args, **kwargs):
return super(cls, calling_cls).from_preset(*args, **kwargs)
cls.from_preset = classmethod(from_preset)
# Format and assign the docstring unless the subclass has overridden it.
if cls.from_preset.__doc__ is None:
cls.from_preset.__func__.__doc__ = (
BytePairTokenizer.from_preset.__doc__
)
format_docstring(
model_name=cls.__name__,
example_preset_name=next(iter(cls.presets), ""),
preset_names='", "'.join(cls.presets),
)(cls.from_preset.__func__)
| [] |
2024-01-10 | andri-jpg/PyWaifu | llm_models.py | import json
from pathlib import Path
from downloader import ModelDownloader
from llm_rs.langchain import RustformersLLM
from llm_rs import Bloom, SessionConfig, GenerationConfig, ContainerType, QuantizationType, Precision
from langchain import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from pathlib import Path
class ChainingModel:
def __init__(self, model, name, assistant_name):
self.model_download = ModelDownloader()
with open('config.json') as self.configuration:
self.user_config = json.load(self.configuration)
meta = f"{model}.meta"
model = f"{model}.bin"
self.model = model
if not Path(model).is_file():
self.model_download.ask_download(f"https://huggingface.co/rustformers/redpajama-3b-ggml/resolve/main/RedPajama-INCITE-Chat-3B-v1-q5_1.bin", model)
if not Path(meta).is_file():
self.model_download.ask_download(f"https://huggingface.co/rustformers/redpajama-3b-ggml/resolve/main/RedPajama-INCITE-Chat-3B-v1-q5_1.meta", meta)
self.name = name
self.assistant_name = assistant_name
self.names = f"<{name}>"
self.assistant_names = f"<{assistant_name}>"
self.stop_word = ['\n<human>:','<human>', '<bot>','\n<bot>:' ]
self.stop_words = self.change_stop_words(self.stop_word, self.name, self.assistant_name)
session_config = SessionConfig(
threads=self.user_config['threads'],
context_length=self.user_config['context_length'],
prefer_mmap=self.user_config['prefer_mmap']
)
generation_config = GenerationConfig(
top_p=self.user_config['top_p'],
top_k=self.user_config['top_k'],
temperature=self.user_config['temperature'],
max_new_tokens=self.user_config['max_new_tokens'],
repetition_penalty=self.user_config['repetition_penalty'],
repetition_penalty_last_n=self.user_config['repetition_penalty_last_n'],
stop_words=self.stop_words
)
template = self.user_config['template']
self.template = self.change_names(template, self.assistant_name, self.name)
self.prompt = PromptTemplate(
input_variables=["chat_history", "instruction"],
template=self.template
)
self.memory = ConversationBufferMemory(memory_key="chat_history")
self.llm = RustformersLLM(
model_path_or_repo_id=self.model,
session_config=session_config,
generation_config=generation_config,
callbacks=[StreamingStdOutCallbackHandler()]
)
self.chain = LLMChain(llm=self.llm, prompt=self.prompt, memory=self.memory)
@staticmethod
def change_stop_words(stop_words, name, assistant_name):
new_stop_words = []
for word in stop_words:
new_word = word.replace('bot', assistant_name)
new_stop_words.append(new_word)
new_word2 = word.replace('human', name)
new_stop_words.append(new_word2)
return new_stop_words
@staticmethod
def change_names(template, assistant_name, user_name):
template = template.replace("bot", assistant_name)
template = template.replace("human", user_name)
return template
def chain(self, input_text):
prompt = self.prompt.generate_prompt({
"chat_history": self.memory.export_memory(),
"instruction": input_text
})
response = self.chain.generate(prompt)
self.memory.add_message(input_text, "human")
self.memory.add_message(response.choices[0].text.strip(), "ai")
return response.choices[0].text.strip()
| [
"chat_history",
"human",
"instruction"
] |
2024-01-10 | CylonSpace/Langchain-Chatchat | document_loaders~myimgloader.py | from typing import List
from langchain.document_loaders.unstructured import UnstructuredFileLoader
class RapidOCRLoader(UnstructuredFileLoader):
def _get_elements(self) -> List:
def img2text(filepath):
from rapidocr_onnxruntime import RapidOCR
resp = ""
ocr = RapidOCR()
result, _ = ocr(filepath)
if result:
ocr_result = [line[1] for line in result]
resp += "\n".join(ocr_result)
return resp
text = img2text(self.file_path)
from unstructured.partition.text import partition_text
return partition_text(text=text, **self.unstructured_kwargs)
if __name__ == "__main__":
loader = RapidOCRLoader(file_path="../tests/samples/ocr_test.jpg")
docs = loader.load()
print(docs)
| [] |
2024-01-10 | ktr03rtk/langchain | tests~unit_tests~agents~test_sql.py | from langchain.agents import create_sql_agent
from langchain.agents.agent_toolkits import SQLDatabaseToolkit
from langchain.sql_database import SQLDatabase
from tests.unit_tests.llms.fake_llm import FakeLLM
def test_create_sql_agent() -> None:
db = SQLDatabase.from_uri("sqlite:///:memory:")
queries = {"foo": "Final Answer: baz"}
llm = FakeLLM(queries=queries, sequential_responses=True)
toolkit = SQLDatabaseToolkit(db=db, llm=llm)
agent_executor = create_sql_agent(
llm=llm,
toolkit=toolkit,
)
assert agent_executor.run("hello") == "baz"
| [] |
2024-01-10 | ktr03rtk/langchain | tests~integration_tests~vectorstores~test_lancedb.py | import lancedb
from langchain.vectorstores import LanceDB
from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
def test_lancedb() -> None:
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1", "text 2", "item 3"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
result = store.similarity_search("text 1")
result_texts = [doc.page_content for doc in result]
assert "text 1" in result_texts
def test_lancedb_add_texts() -> None:
embeddings = FakeEmbeddings()
db = lancedb.connect("/tmp/lancedb")
texts = ["text 1"]
vectors = embeddings.embed_documents(texts)
table = db.create_table(
"my_table",
data=[
{"vector": vectors[idx], "id": text, "text": text}
for idx, text in enumerate(texts)
],
mode="overwrite",
)
store = LanceDB(table, embeddings)
store.add_texts(["text 2"])
result = store.similarity_search("text 2")
result_texts = [doc.page_content for doc in result]
assert "text 2" in result_texts
| [] |
2024-01-10 | ktr03rtk/langchain | tests~integration_tests~llms~test_huggingface_pipeline.py | """Test HuggingFace Pipeline wrapper."""
from pathlib import Path
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langchain.llms.huggingface_pipeline import HuggingFacePipeline
from langchain.llms.loading import load_llm
from tests.integration_tests.llms.utils import assert_llm_equality
def test_huggingface_pipeline_text_generation() -> None:
"""Test valid call to HuggingFace text generation model."""
llm = HuggingFacePipeline.from_model_id(
model_id="gpt2", task="text-generation", model_kwargs={"max_new_tokens": 10}
)
output = llm("Say foo:")
assert isinstance(output, str)
def test_huggingface_pipeline_text2text_generation() -> None:
"""Test valid call to HuggingFace text2text generation model."""
llm = HuggingFacePipeline.from_model_id(
model_id="google/flan-t5-small", task="text2text-generation"
)
output = llm("Say foo:")
assert isinstance(output, str)
def text_huggingface_pipeline_summarization() -> None:
"""Test valid call to HuggingFace summarization model."""
llm = HuggingFacePipeline.from_model_id(
model_id="facebook/bart-large-cnn", task="summarization"
)
output = llm("Say foo:")
assert isinstance(output, str)
def test_saving_loading_llm(tmp_path: Path) -> None:
"""Test saving/loading an HuggingFaceHub LLM."""
llm = HuggingFacePipeline.from_model_id(
model_id="gpt2", task="text-generation", model_kwargs={"max_new_tokens": 10}
)
llm.save(file_path=tmp_path / "hf.yaml")
loaded_llm = load_llm(tmp_path / "hf.yaml")
assert_llm_equality(llm, loaded_llm)
def test_init_with_pipeline() -> None:
"""Test initialization with a HF pipeline."""
model_id = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
pipe = pipeline(
"text-generation", model=model, tokenizer=tokenizer, max_new_tokens=10
)
llm = HuggingFacePipeline(pipeline=pipe)
output = llm("Say foo:")
assert isinstance(output, str)
| [] |
2024-01-10 | ktr03rtk/langchain | tests~integration_tests~test_document_transformers.py | """Integration test for embedding-based redundant doc filtering."""
from langchain.document_transformers import (
EmbeddingsRedundantFilter,
_DocumentWithState,
)
from langchain.embeddings import OpenAIEmbeddings
from langchain.schema import Document
def test_embeddings_redundant_filter() -> None:
texts = [
"What happened to all of my cookies?",
"Where did all of my cookies go?",
"I wish there were better Italian restaurants in my neighborhood.",
]
docs = [Document(page_content=t) for t in texts]
embeddings = OpenAIEmbeddings()
redundant_filter = EmbeddingsRedundantFilter(embeddings=embeddings)
actual = redundant_filter.transform_documents(docs)
assert len(actual) == 2
assert set(texts[:2]).intersection([d.page_content for d in actual])
def test_embeddings_redundant_filter_with_state() -> None:
texts = ["What happened to all of my cookies?", "foo bar baz"]
state = {"embedded_doc": [0.5] * 10}
docs = [_DocumentWithState(page_content=t, state=state) for t in texts]
embeddings = OpenAIEmbeddings()
redundant_filter = EmbeddingsRedundantFilter(embeddings=embeddings)
actual = redundant_filter.transform_documents(docs)
assert len(actual) == 1
| [] |
2024-01-10 | ktr03rtk/langchain | langchain~agents~agent_toolkits~powerbi~toolkit.py | """Toolkit for interacting with a Power BI dataset."""
from typing import List, Optional
from pydantic import Field
from langchain.agents.agent_toolkits.base import BaseToolkit
from langchain.base_language import BaseLanguageModel
from langchain.callbacks.base import BaseCallbackManager
from langchain.chains.llm import LLMChain
from langchain.prompts import PromptTemplate
from langchain.tools import BaseTool
from langchain.tools.powerbi.prompt import QUESTION_TO_QUERY
from langchain.tools.powerbi.tool import (
InfoPowerBITool,
ListPowerBITool,
QueryPowerBITool,
)
from langchain.utilities.powerbi import PowerBIDataset
class PowerBIToolkit(BaseToolkit):
"""Toolkit for interacting with PowerBI dataset."""
powerbi: PowerBIDataset = Field(exclude=True)
llm: BaseLanguageModel = Field(exclude=True)
examples: Optional[str] = None
max_iterations: int = 5
callback_manager: Optional[BaseCallbackManager] = None
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
def get_tools(self) -> List[BaseTool]:
"""Get the tools in the toolkit."""
if self.callback_manager:
chain = LLMChain(
llm=self.llm,
callback_manager=self.callback_manager,
prompt=PromptTemplate(
template=QUESTION_TO_QUERY,
input_variables=["tool_input", "tables", "schemas", "examples"],
),
)
else:
chain = LLMChain(
llm=self.llm,
prompt=PromptTemplate(
template=QUESTION_TO_QUERY,
input_variables=["tool_input", "tables", "schemas", "examples"],
),
)
return [
QueryPowerBITool(
llm_chain=chain,
powerbi=self.powerbi,
examples=self.examples,
max_iterations=self.max_iterations,
),
InfoPowerBITool(powerbi=self.powerbi),
ListPowerBITool(powerbi=self.powerbi),
]
| [] |
2024-01-10 | ktr03rtk/langchain | tests~integration_tests~agent~test_csv_agent.py | import re
import numpy as np
import pytest
from _pytest.tmpdir import TempPathFactory
from pandas import DataFrame
from langchain.agents import create_csv_agent
from langchain.agents.agent import AgentExecutor
from langchain.llms import OpenAI
@pytest.fixture(scope="module")
def csv(tmp_path_factory: TempPathFactory) -> DataFrame:
random_data = np.random.rand(4, 4)
df = DataFrame(random_data, columns=["name", "age", "food", "sport"])
filename = str(tmp_path_factory.mktemp("data") / "test.csv")
df.to_csv(filename)
return filename
@pytest.fixture(scope="module")
def csv_list(tmp_path_factory: TempPathFactory) -> DataFrame:
random_data = np.random.rand(4, 4)
df1 = DataFrame(random_data, columns=["name", "age", "food", "sport"])
filename1 = str(tmp_path_factory.mktemp("data") / "test1.csv")
df1.to_csv(filename1)
random_data = np.random.rand(2, 2)
df2 = DataFrame(random_data, columns=["name", "height"])
filename2 = str(tmp_path_factory.mktemp("data") / "test2.csv")
df2.to_csv(filename2)
return [filename1, filename2]
def test_csv_agent_creation(csv: str) -> None:
agent = create_csv_agent(OpenAI(temperature=0), csv)
assert isinstance(agent, AgentExecutor)
def test_single_csv(csv: str) -> None:
agent = create_csv_agent(OpenAI(temperature=0), csv)
assert isinstance(agent, AgentExecutor)
response = agent.run("How many rows in the csv? Give me a number.")
result = re.search(r".*(4).*", response)
assert result is not None
assert result.group(1) is not None
def test_multi_csv(csv_list: list) -> None:
agent = create_csv_agent(OpenAI(temperature=0), csv_list, verbose=True)
assert isinstance(agent, AgentExecutor)
response = agent.run("How many combined rows in the two csvs? Give me a number.")
result = re.search(r".*(6).*", response)
assert result is not None
assert result.group(1) is not None
| [] |
2024-01-10 | ktr03rtk/langchain | langchain~retrievers~self_query~pinecone.py | """Logic for converting internal query language to a valid Pinecone query."""
from typing import Dict, Tuple, Union
from langchain.chains.query_constructor.ir import (
Comparator,
Comparison,
Operation,
Operator,
StructuredQuery,
Visitor,
)
class PineconeTranslator(Visitor):
"""Logic for converting internal query language elements to valid filters."""
allowed_operators = [Operator.AND, Operator.OR]
"""Subset of allowed logical operators."""
def _format_func(self, func: Union[Operator, Comparator]) -> str:
self._validate_func(func)
return f"${func.value}"
def visit_operation(self, operation: Operation) -> Dict:
args = [arg.accept(self) for arg in operation.arguments]
return {self._format_func(operation.operator): args}
def visit_comparison(self, comparison: Comparison) -> Dict:
return {
comparison.attribute: {
self._format_func(comparison.comparator): comparison.value
}
}
def visit_structured_query(
self, structured_query: StructuredQuery
) -> Tuple[str, dict]:
if structured_query.filter is None:
kwargs = {}
else:
kwargs = {"filter": structured_query.filter.accept(self)}
return structured_query.query, kwargs
| [] |
2024-01-10 | ktr03rtk/langchain | tests~integration_tests~retrievers~document_compressors~test_embeddings_filter.py | """Integration test for embedding-based relevant doc filtering."""
import numpy as np
from langchain.document_transformers import _DocumentWithState
from langchain.embeddings import OpenAIEmbeddings
from langchain.retrievers.document_compressors import EmbeddingsFilter
from langchain.schema import Document
def test_embeddings_filter() -> None:
texts = [
"What happened to all of my cookies?",
"I wish there were better Italian restaurants in my neighborhood.",
"My favorite color is green",
]
docs = [Document(page_content=t) for t in texts]
embeddings = OpenAIEmbeddings()
relevant_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.75)
actual = relevant_filter.compress_documents(docs, "What did I say about food?")
assert len(actual) == 2
assert len(set(texts[:2]).intersection([d.page_content for d in actual])) == 2
def test_embeddings_filter_with_state() -> None:
texts = [
"What happened to all of my cookies?",
"I wish there were better Italian restaurants in my neighborhood.",
"My favorite color is green",
]
query = "What did I say about food?"
embeddings = OpenAIEmbeddings()
embedded_query = embeddings.embed_query(query)
state = {"embedded_doc": np.zeros(len(embedded_query))}
docs = [_DocumentWithState(page_content=t, state=state) for t in texts]
docs[-1].state = {"embedded_doc": embedded_query}
relevant_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=0.75)
actual = relevant_filter.compress_documents(docs, query)
assert len(actual) == 1
assert texts[-1] == actual[0].page_content
| [] |
2024-01-10 | ktr03rtk/langchain | langchain~chat_models~azure_openai.py | """Azure OpenAI chat wrapper."""
from __future__ import annotations
import logging
from typing import Any, Dict, Mapping
from pydantic import root_validator
from langchain.chat_models.openai import ChatOpenAI
from langchain.schema import ChatResult
from langchain.utils import get_from_dict_or_env
logger = logging.getLogger(__name__)
class AzureChatOpenAI(ChatOpenAI):
"""Wrapper around Azure OpenAI Chat Completion API. To use this class you
must have a deployed model on Azure OpenAI. Use `deployment_name` in the
constructor to refer to the "Model deployment name" in the Azure portal.
In addition, you should have the ``openai`` python package installed, and the
following environment variables set or passed in constructor in lower case:
- ``OPENAI_API_TYPE`` (default: ``azure``)
- ``OPENAI_API_KEY``
- ``OPENAI_API_BASE``
- ``OPENAI_API_VERSION``
- ``OPENAI_PROXY``
For exmaple, if you have `gpt-35-turbo` deployed, with the deployment name
`35-turbo-dev`, the constructor should look like:
.. code-block:: python
AzureChatOpenAI(
deployment_name="35-turbo-dev",
openai_api_version="2023-03-15-preview",
)
Be aware the API version may change.
Any parameters that are valid to be passed to the openai.create call can be passed
in, even if not explicitly saved on this class.
"""
deployment_name: str = ""
openai_api_type: str = "azure"
openai_api_base: str = ""
openai_api_version: str = ""
openai_api_key: str = ""
openai_organization: str = ""
openai_proxy: str = ""
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that api key and python package exists in environment."""
values["openai_api_key"] = get_from_dict_or_env(
values,
"openai_api_key",
"OPENAI_API_KEY",
)
values["openai_api_base"] = get_from_dict_or_env(
values,
"openai_api_base",
"OPENAI_API_BASE",
)
values["openai_api_version"] = get_from_dict_or_env(
values,
"openai_api_version",
"OPENAI_API_VERSION",
)
values["openai_api_type"] = get_from_dict_or_env(
values,
"openai_api_type",
"OPENAI_API_TYPE",
)
values["openai_organization"] = get_from_dict_or_env(
values,
"openai_organization",
"OPENAI_ORGANIZATION",
default="",
)
values["openai_proxy"] = get_from_dict_or_env(
values,
"openai_proxy",
"OPENAI_PROXY",
default="",
)
try:
import openai
except ImportError:
raise ImportError(
"Could not import openai python package. "
"Please install it with `pip install openai`."
)
try:
values["client"] = openai.ChatCompletion
except AttributeError:
raise ValueError(
"`openai` has no `ChatCompletion` attribute, this is likely "
"due to an old version of the openai package. Try upgrading it "
"with `pip install --upgrade openai`."
)
if values["n"] < 1:
raise ValueError("n must be at least 1.")
if values["n"] > 1 and values["streaming"]:
raise ValueError("n must be 1 when streaming.")
return values
@property
def _default_params(self) -> Dict[str, Any]:
"""Get the default parameters for calling OpenAI API."""
return {
**super()._default_params,
"engine": self.deployment_name,
}
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {**self._default_params}
@property
def _invocation_params(self) -> Mapping[str, Any]:
openai_creds = {
"api_type": self.openai_api_type,
"api_version": self.openai_api_version,
}
return {**openai_creds, **super()._invocation_params}
@property
def _llm_type(self) -> str:
return "azure-openai-chat"
def _create_chat_result(self, response: Mapping[str, Any]) -> ChatResult:
for res in response["choices"]:
if res.get("finish_reason", None) == "content_filter":
raise ValueError(
"Azure has not provided the response due to a content"
" filter being triggered"
)
return super()._create_chat_result(response)
| [] |
2024-01-10 | ktr03rtk/langchain | langchain~embeddings~bedrock.py | import json
import os
from typing import Any, Dict, List, Optional
from pydantic import BaseModel, Extra, root_validator
from langchain.embeddings.base import Embeddings
class BedrockEmbeddings(BaseModel, Embeddings):
"""Embeddings provider to invoke Bedrock embedding models.
To authenticate, the AWS client uses the following methods to
automatically load credentials:
https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
If a specific credential profile should be used, you must pass
the name of the profile from the ~/.aws/credentials file that is to be used.
Make sure the credentials / roles used have the required policies to
access the Bedrock service.
"""
"""
Example:
.. code-block:: python
from langchain.bedrock_embeddings import BedrockEmbeddings
region_name ="us-east-1"
credentials_profile_name = "default"
model_id = "amazon.titan-e1t-medium"
be = BedrockEmbeddings(
credentials_profile_name=credentials_profile_name,
region_name=region_name,
model_id=model_id
)
"""
client: Any #: :meta private:
region_name: Optional[str] = None
"""The aws region e.g., `us-west-2`. Fallsback to AWS_DEFAULT_REGION env variable
or region specified in ~/.aws/config in case it is not provided here.
"""
credentials_profile_name: Optional[str] = None
"""The name of the profile in the ~/.aws/credentials or ~/.aws/config files, which
has either access keys or role information specified.
If not specified, the default credential profile or, if on an EC2 instance,
credentials from IMDS will be used.
See: https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
"""
model_id: str = "amazon.titan-e1t-medium"
"""Id of the model to call, e.g., amazon.titan-e1t-medium, this is
equivalent to the modelId property in the list-foundation-models api"""
model_kwargs: Optional[Dict] = None
"""Key word arguments to pass to the model."""
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that AWS credentials to and python package exists in environment."""
if values["client"] is not None:
return values
try:
import boto3
if values["credentials_profile_name"] is not None:
session = boto3.Session(profile_name=values["credentials_profile_name"])
else:
# use default credentials
session = boto3.Session()
client_params = {}
if values["region_name"]:
client_params["region_name"] = values["region_name"]
values["client"] = session.client("bedrock", **client_params)
except ImportError:
raise ModuleNotFoundError(
"Could not import boto3 python package. "
"Please install it with `pip install boto3`."
)
except Exception as e:
raise ValueError(
"Could not load credentials to authenticate with AWS client. "
"Please check that credentials in the specified "
"profile name are valid."
) from e
return values
def _embedding_func(self, text: str) -> List[float]:
"""Call out to Bedrock embedding endpoint."""
# replace newlines, which can negatively affect performance.
text = text.replace(os.linesep, " ")
_model_kwargs = self.model_kwargs or {}
input_body = {**_model_kwargs}
input_body["inputText"] = text
body = json.dumps(input_body)
content_type = "application/json"
accepts = "application/json"
embeddings = []
try:
response = self.client.invoke_model(
body=body,
modelId=self.model_id,
accept=accepts,
contentType=content_type,
)
response_body = json.loads(response.get("body").read())
embeddings = response_body.get("embedding")
except Exception as e:
raise ValueError(f"Error raised by inference endpoint: {e}")
return embeddings
def embed_documents(
self, texts: List[str], chunk_size: int = 1
) -> List[List[float]]:
"""Compute doc embeddings using a Bedrock model.
Args:
texts: The list of texts to embed.
chunk_size: Bedrock currently only allows single string
inputs, so chunk size is always 1. This input is here
only for compatibility with the embeddings interface.
Returns:
List of embeddings, one for each text.
"""
results = []
for text in texts:
response = self._embedding_func(text)
results.append(response)
return results
def embed_query(self, text: str) -> List[float]:
"""Compute query embeddings using a Bedrock model.
Args:
text: The text to embed.
Returns:
Embeddings for the text.
"""
return self._embedding_func(text)
| [] |
2024-01-10 | ktr03rtk/langchain | langchain~chains~router~multi_prompt.py | """Use a single chain to route an input to one of multiple llm chains."""
from __future__ import annotations
from typing import Any, Dict, List, Mapping, Optional
from langchain.base_language import BaseLanguageModel
from langchain.chains import ConversationChain
from langchain.chains.llm import LLMChain
from langchain.chains.router.base import MultiRouteChain, RouterChain
from langchain.chains.router.llm_router import LLMRouterChain, RouterOutputParser
from langchain.chains.router.multi_prompt_prompt import MULTI_PROMPT_ROUTER_TEMPLATE
from langchain.prompts import PromptTemplate
class MultiPromptChain(MultiRouteChain):
"""A multi-route chain that uses an LLM router chain to choose amongst prompts."""
router_chain: RouterChain
"""Chain for deciding a destination chain and the input to it."""
destination_chains: Mapping[str, LLMChain]
"""Map of name to candidate chains that inputs can be routed to."""
default_chain: LLMChain
"""Default chain to use when router doesn't map input to one of the destinations."""
@property
def output_keys(self) -> List[str]:
return ["text"]
@classmethod
def from_prompts(
cls,
llm: BaseLanguageModel,
prompt_infos: List[Dict[str, str]],
default_chain: Optional[LLMChain] = None,
**kwargs: Any,
) -> MultiPromptChain:
"""Convenience constructor for instantiating from destination prompts."""
destinations = [f"{p['name']}: {p['description']}" for p in prompt_infos]
destinations_str = "\n".join(destinations)
router_template = MULTI_PROMPT_ROUTER_TEMPLATE.format(
destinations=destinations_str
)
router_prompt = PromptTemplate(
template=router_template,
input_variables=["input"],
output_parser=RouterOutputParser(),
)
router_chain = LLMRouterChain.from_llm(llm, router_prompt)
destination_chains = {}
for p_info in prompt_infos:
name = p_info["name"]
prompt_template = p_info["prompt_template"]
prompt = PromptTemplate(template=prompt_template, input_variables=["input"])
chain = LLMChain(llm=llm, prompt=prompt)
destination_chains[name] = chain
_default_chain = default_chain or ConversationChain(llm=llm, output_key="text")
return cls(
router_chain=router_chain,
destination_chains=destination_chains,
default_chain=_default_chain,
**kwargs,
)
| [
"input",
"prompt_template"
] |
2024-01-10 | ktr03rtk/langchain | langchain~example_generator.py | """Utility functions for working with prompts."""
from typing import List
from langchain.base_language import BaseLanguageModel
from langchain.chains.llm import LLMChain
from langchain.prompts.few_shot import FewShotPromptTemplate
from langchain.prompts.prompt import PromptTemplate
TEST_GEN_TEMPLATE_SUFFIX = "Add another example."
def generate_example(
examples: List[dict], llm: BaseLanguageModel, prompt_template: PromptTemplate
) -> str:
"""Return another example given a list of examples for a prompt."""
prompt = FewShotPromptTemplate(
examples=examples,
suffix=TEST_GEN_TEMPLATE_SUFFIX,
input_variables=[],
example_prompt=prompt_template,
)
chain = LLMChain(llm=llm, prompt=prompt)
return chain.predict()
| [
"Add another example."
] |
2024-01-10 | ktr03rtk/langchain | langchain~memory~simple.py | from typing import Any, Dict, List
from langchain.schema import BaseMemory
class SimpleMemory(BaseMemory):
"""Simple memory for storing context or other bits of information that shouldn't
ever change between prompts.
"""
memories: Dict[str, Any] = dict()
@property
def memory_variables(self) -> List[str]:
return list(self.memories.keys())
def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
return self.memories
def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
"""Nothing should be saved or changed, my memory is set in stone."""
pass
def clear(self) -> None:
"""Nothing to clear, got a memory like a vault."""
pass
| [] |
2024-01-10 | ktr03rtk/langchain | langchain~agents~agent_toolkits~spark_sql~toolkit.py | """Toolkit for interacting with Spark SQL."""
from typing import List
from pydantic import Field
from langchain.agents.agent_toolkits.base import BaseToolkit
from langchain.base_language import BaseLanguageModel
from langchain.tools import BaseTool
from langchain.tools.spark_sql.tool import (
InfoSparkSQLTool,
ListSparkSQLTool,
QueryCheckerTool,
QuerySparkSQLTool,
)
from langchain.utilities.spark_sql import SparkSQL
class SparkSQLToolkit(BaseToolkit):
"""Toolkit for interacting with Spark SQL."""
db: SparkSQL = Field(exclude=True)
llm: BaseLanguageModel = Field(exclude=True)
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
def get_tools(self) -> List[BaseTool]:
"""Get the tools in the toolkit."""
return [
QuerySparkSQLTool(db=self.db),
InfoSparkSQLTool(db=self.db),
ListSparkSQLTool(db=self.db),
QueryCheckerTool(db=self.db, llm=self.llm),
]
| [] |
2024-01-10 | ktr03rtk/langchain | tests~integration_tests~retrievers~test_merger_retriever.py | from langchain.embeddings import OpenAIEmbeddings
from langchain.retrievers.merger_retriever import MergerRetriever
from langchain.vectorstores import Chroma
def test_merger_retriever_get_relevant_docs() -> None:
"""Test get_relevant_docs."""
texts_group_a = [
"This is a document about the Boston Celtics",
"Fly me to the moon is one of my favourite songs."
"I simply love going to the movies",
]
texts_group_b = [
"This is a document about the Poenix Suns",
"The Boston Celtics won the game by 20 points",
"Real stupidity beats artificial intelligence every time. TP",
]
embeddings = OpenAIEmbeddings()
retriever_a = Chroma.from_texts(texts_group_a, embedding=embeddings).as_retriever(
search_kwargs={"k": 1}
)
retriever_b = Chroma.from_texts(texts_group_b, embedding=embeddings).as_retriever(
search_kwargs={"k": 1}
)
# The Lord of the Retrievers.
lotr = MergerRetriever([retriever_a, retriever_b])
actual = lotr.get_relevant_documents("Tell me about the Celtics")
assert len(actual) == 2
assert texts_group_a[0] in [d.page_content for d in actual]
assert texts_group_b[1] in [d.page_content for d in actual]
| [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.