mlara commited on
Commit
f4b691b
1 Parent(s): ef04f12

first commit

Browse files
Dockerfile ADDED
@@ -0,0 +1,11 @@
 
 
 
 
 
 
 
 
 
 
 
 
1
+ FROM python:3.9
2
+ RUN useradd -m -u 1000 user
3
+ USER user
4
+ ENV HOME=/home/user \
5
+ PATH=/home/user/.local/bin:$PATH
6
+ WORKDIR $HOME/app
7
+ COPY --chown=user . $HOME/app
8
+ COPY ./requirements.txt ~/app/requirements.txt
9
+ RUN pip install -r requirements.txt
10
+ COPY . .
11
+ CMD ["chainlit", "run", "app.py", "--port", "7860"]
aimakerspace/__init__.py ADDED
File without changes
aimakerspace/__pycache__/__init__.cpython-39.pyc ADDED
Binary file (237 Bytes). View file
 
aimakerspace/__pycache__/text_utils.cpython-39.pyc ADDED
Binary file (2.95 kB). View file
 
aimakerspace/__pycache__/vectordatabase.cpython-39.pyc ADDED
Binary file (3.64 kB). View file
 
aimakerspace/openai_utils/__init__.py ADDED
File without changes
aimakerspace/openai_utils/__pycache__/__init__.cpython-39.pyc ADDED
Binary file (250 Bytes). View file
 
aimakerspace/openai_utils/__pycache__/chatmodel.cpython-39.pyc ADDED
Binary file (1.19 kB). View file
 
aimakerspace/openai_utils/__pycache__/embedding.cpython-39.pyc ADDED
Binary file (2.55 kB). View file
 
aimakerspace/openai_utils/__pycache__/prompts.cpython-39.pyc ADDED
Binary file (3.73 kB). View file
 
aimakerspace/openai_utils/chatmodel.py ADDED
@@ -0,0 +1,27 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from openai import OpenAI
2
+ from dotenv import load_dotenv
3
+ import os
4
+
5
+ load_dotenv()
6
+
7
+
8
+ class ChatOpenAI:
9
+ def __init__(self, model_name: str = "gpt-3.5-turbo"):
10
+ self.model_name = model_name
11
+ self.openai_api_key = os.getenv("OPENAI_API_KEY")
12
+ if self.openai_api_key is None:
13
+ raise ValueError("OPENAI_API_KEY is not set")
14
+
15
+ def run(self, messages, text_only: bool = True):
16
+ if not isinstance(messages, list):
17
+ raise ValueError("messages must be a list")
18
+
19
+ client = OpenAI()
20
+ response = client.chat.completions.create(
21
+ model=self.model_name, messages=messages
22
+ )
23
+
24
+ if text_only:
25
+ return response.choices[0].message.content
26
+
27
+ return response
aimakerspace/openai_utils/embedding.py ADDED
@@ -0,0 +1,59 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from dotenv import load_dotenv
2
+ from openai import AsyncOpenAI, OpenAI
3
+ import openai
4
+ from typing import List
5
+ import os
6
+ import asyncio
7
+
8
+
9
+ class EmbeddingModel:
10
+ def __init__(self, embeddings_model_name: str = "text-embedding-ada-002"):
11
+ load_dotenv()
12
+ self.openai_api_key = os.getenv("OPENAI_API_KEY")
13
+ self.async_client = AsyncOpenAI()
14
+ self.client = OpenAI()
15
+
16
+ if self.openai_api_key is None:
17
+ raise ValueError(
18
+ "OPENAI_API_KEY environment variable is not set. Please set it to your OpenAI API key."
19
+ )
20
+ openai.api_key = self.openai_api_key
21
+ self.embeddings_model_name = embeddings_model_name
22
+
23
+ async def async_get_embeddings(self, list_of_text: List[str]) -> List[List[float]]:
24
+ embedding_response = await self.async_client.embeddings.create(
25
+ input=list_of_text, model=self.embeddings_model_name
26
+ )
27
+
28
+ return [embeddings.embedding for embeddings in embedding_response.data]
29
+
30
+ async def async_get_embedding(self, text: str) -> List[float]:
31
+ embedding = await self.async_client.embeddings.create(
32
+ input=text, model=self.embeddings_model_name
33
+ )
34
+
35
+ return embedding.data[0].embedding
36
+
37
+ def get_embeddings(self, list_of_text: List[str]) -> List[List[float]]:
38
+ embedding_response = self.client.embeddings.create(
39
+ input=list_of_text, model=self.embeddings_model_name
40
+ )
41
+
42
+ return [embeddings.embedding for embeddings in embedding_response.data]
43
+
44
+ def get_embedding(self, text: str) -> List[float]:
45
+ embedding = self.client.embeddings.create(
46
+ input=text, model=self.embeddings_model_name
47
+ )
48
+
49
+ return embedding.data[0].embedding
50
+
51
+
52
+ if __name__ == "__main__":
53
+ embedding_model = EmbeddingModel()
54
+ print(asyncio.run(embedding_model.async_get_embedding("Hello, world!")))
55
+ print(
56
+ asyncio.run(
57
+ embedding_model.async_get_embeddings(["Hello, world!", "Goodbye, world!"])
58
+ )
59
+ )
aimakerspace/openai_utils/prompts.py ADDED
@@ -0,0 +1,75 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import re
2
+
3
+
4
+ class BasePrompt:
5
+ def __init__(self, prompt):
6
+ """
7
+ Initializes the BasePrompt object with a prompt template.
8
+
9
+ :param prompt: A string that can contain placeholders within curly braces
10
+ """
11
+ self.prompt = prompt
12
+ self._pattern = re.compile(r"\{([^}]+)\}")
13
+
14
+ def format_prompt(self, **kwargs):
15
+ """
16
+ Formats the prompt string using the keyword arguments provided.
17
+
18
+ :param kwargs: The values to substitute into the prompt string
19
+ :return: The formatted prompt string
20
+ """
21
+ matches = self._pattern.findall(self.prompt)
22
+ return self.prompt.format(**{match: kwargs.get(match, "") for match in matches})
23
+
24
+ def get_input_variables(self):
25
+ """
26
+ Gets the list of input variable names from the prompt string.
27
+
28
+ :return: List of input variable names
29
+ """
30
+ return self._pattern.findall(self.prompt)
31
+
32
+
33
+ class RolePrompt(BasePrompt):
34
+ def __init__(self, prompt, role: str):
35
+ """
36
+ Initializes the RolePrompt object with a prompt template and a role.
37
+
38
+ :param prompt: A string that can contain placeholders within curly braces
39
+ :param role: The role for the message ('system', 'user', or 'assistant')
40
+ """
41
+ super().__init__(prompt)
42
+ self.role = role
43
+
44
+ def create_message(self, **kwargs):
45
+ """
46
+ Creates a message dictionary with a role and a formatted message.
47
+
48
+ :param kwargs: The values to substitute into the prompt string
49
+ :return: Dictionary containing the role and the formatted message
50
+ """
51
+ return {"role": self.role, "content": self.format_prompt(**kwargs)}
52
+
53
+
54
+ class SystemRolePrompt(RolePrompt):
55
+ def __init__(self, prompt: str):
56
+ super().__init__(prompt, "system")
57
+
58
+
59
+ class UserRolePrompt(RolePrompt):
60
+ def __init__(self, prompt: str):
61
+ super().__init__(prompt, "user")
62
+
63
+
64
+ class AssistantRolePrompt(RolePrompt):
65
+ def __init__(self, prompt: str):
66
+ super().__init__(prompt, "assistant")
67
+
68
+
69
+ if __name__ == "__main__":
70
+ prompt = BasePrompt("Hello {name}, you are {age} years old")
71
+ print(prompt.format_prompt(name="John", age=30))
72
+
73
+ prompt = SystemRolePrompt("Hello {name}, you are {age} years old")
74
+ print(prompt.create_message(name="John", age=30))
75
+ print(prompt.get_input_variables())
aimakerspace/text_utils.py ADDED
@@ -0,0 +1,77 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import os
2
+ from typing import List
3
+
4
+
5
+ class TextFileLoader:
6
+ def __init__(self, path: str, encoding: str = "utf-8"):
7
+ self.documents = []
8
+ self.path = path
9
+ self.encoding = encoding
10
+
11
+ def load(self):
12
+ if os.path.isdir(self.path):
13
+ self.load_directory()
14
+ elif os.path.isfile(self.path) and self.path.endswith(".txt"):
15
+ self.load_file()
16
+ else:
17
+ raise ValueError(
18
+ "Provided path is neither a valid directory nor a .txt file."
19
+ )
20
+
21
+ def load_file(self):
22
+ with open(self.path, "r", encoding=self.encoding) as f:
23
+ self.documents.append(f.read())
24
+
25
+ def load_directory(self):
26
+ for root, _, files in os.walk(self.path):
27
+ for file in files:
28
+ if file.endswith(".txt"):
29
+ with open(
30
+ os.path.join(root, file), "r", encoding=self.encoding
31
+ ) as f:
32
+ self.documents.append(f.read())
33
+
34
+ def load_documents(self):
35
+ self.load()
36
+ return self.documents
37
+
38
+
39
+ class CharacterTextSplitter:
40
+ def __init__(
41
+ self,
42
+ chunk_size: int = 1000,
43
+ chunk_overlap: int = 200,
44
+ ):
45
+ assert (
46
+ chunk_size > chunk_overlap
47
+ ), "Chunk size must be greater than chunk overlap"
48
+
49
+ self.chunk_size = chunk_size
50
+ self.chunk_overlap = chunk_overlap
51
+
52
+ def split(self, text: str) -> List[str]:
53
+ chunks = []
54
+ for i in range(0, len(text), self.chunk_size - self.chunk_overlap):
55
+ chunks.append(text[i : i + self.chunk_size])
56
+ return chunks
57
+
58
+ def split_texts(self, texts: List[str]) -> List[str]:
59
+ chunks = []
60
+ for text in texts:
61
+ chunks.extend(self.split(text))
62
+ return chunks
63
+
64
+
65
+ if __name__ == "__main__":
66
+ loader = TextFileLoader("data/KingLear.txt")
67
+ loader.load()
68
+ splitter = CharacterTextSplitter()
69
+ chunks = splitter.split_texts(loader.documents)
70
+ print(len(chunks))
71
+ print(chunks[0])
72
+ print("--------")
73
+ print(chunks[1])
74
+ print("--------")
75
+ print(chunks[-2])
76
+ print("--------")
77
+ print(chunks[-1])
aimakerspace/vectordatabase.py ADDED
@@ -0,0 +1,81 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import numpy as np
2
+ from collections import defaultdict
3
+ from typing import List, Tuple, Callable
4
+ from aimakerspace.openai_utils.embedding import EmbeddingModel
5
+ import asyncio
6
+
7
+
8
+ def cosine_similarity(vector_a: np.array, vector_b: np.array) -> float:
9
+ """Computes the cosine similarity between two vectors."""
10
+ dot_product = np.dot(vector_a, vector_b)
11
+ norm_a = np.linalg.norm(vector_a)
12
+ norm_b = np.linalg.norm(vector_b)
13
+ return dot_product / (norm_a * norm_b)
14
+
15
+
16
+ class VectorDatabase:
17
+ def __init__(self, embedding_model: EmbeddingModel = None):
18
+ self.vectors = defaultdict(np.array)
19
+ self.embedding_model = embedding_model or EmbeddingModel()
20
+
21
+ def insert(self, key: str, vector: np.array) -> None:
22
+ self.vectors[key] = vector
23
+
24
+ def search(
25
+ self,
26
+ query_vector: np.array,
27
+ k: int,
28
+ distance_measure: Callable = cosine_similarity,
29
+ ) -> List[Tuple[str, float]]:
30
+ scores = [
31
+ (key, distance_measure(query_vector, vector))
32
+ for key, vector in self.vectors.items()
33
+ ]
34
+ return sorted(scores, key=lambda x: x[1], reverse=True)[:k]
35
+
36
+ def search_by_text(
37
+ self,
38
+ query_text: str,
39
+ k: int,
40
+ distance_measure: Callable = cosine_similarity,
41
+ return_as_text: bool = False,
42
+ ) -> List[Tuple[str, float]]:
43
+ query_vector = self.embedding_model.get_embedding(query_text)
44
+ results = self.search(query_vector, k, distance_measure)
45
+ return [result[0] for result in results] if return_as_text else results
46
+
47
+ def retrieve_from_key(self, key: str) -> np.array:
48
+ return self.vectors.get(key, None)
49
+
50
+ async def abuild_from_list(self, list_of_text: List[str]) -> "VectorDatabase":
51
+ embeddings = await self.embedding_model.async_get_embeddings(list_of_text)
52
+ for text, embedding in zip(list_of_text, embeddings):
53
+ self.insert(text, np.array(embedding))
54
+ return self
55
+
56
+
57
+ if __name__ == "__main__":
58
+ list_of_text = [
59
+ "I like to eat broccoli and bananas.",
60
+ "I ate a banana and spinach smoothie for breakfast.",
61
+ "Chinchillas and kittens are cute.",
62
+ "My sister adopted a kitten yesterday.",
63
+ "Look at this cute hamster munching on a piece of broccoli.",
64
+ ]
65
+
66
+ vector_db = VectorDatabase()
67
+ vector_db = asyncio.run(vector_db.abuild_from_list(list_of_text))
68
+ k = 2
69
+
70
+ searched_vector = vector_db.search_by_text("I think fruit is awesome!", k=k)
71
+ print(f"Closest {k} vector(s):", searched_vector)
72
+
73
+ retrieved_vector = vector_db.retrieve_from_key(
74
+ "I like to eat broccoli and bananas."
75
+ )
76
+ print("Retrieved vector:", retrieved_vector)
77
+
78
+ relevant_texts = vector_db.search_by_text(
79
+ "I think fruit is awesome!", k=k, return_as_text=True
80
+ )
81
+ print(f"Closest {k} text(s):", relevant_texts)
app.py ADDED
@@ -0,0 +1,62 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # You can find this code for Chainlit python streaming here (https://docs.chainlit.io/concepts/streaming/python)
2
+
3
+ # OpenAI Chat completion
4
+ import os
5
+ import sys
6
+ from openai import AsyncOpenAI # importing openai for API usage
7
+ import chainlit as cl # importing chainlit for our app
8
+ from chainlit.prompt import Prompt, PromptMessage # importing prompt tools
9
+ from chainlit.playground.providers import ChatOpenAI # importing ChatOpenAI tools
10
+ from dotenv import load_dotenv
11
+
12
+ load_dotenv()
13
+
14
+ from rag import retrieval_augmented_qa_pipeline
15
+
16
+ # Add path to the root of the repo to the system path
17
+ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
18
+
19
+
20
+ # ChatOpenAI Templates
21
+ system_template = """You are a helpful assistant who always speaks in a pleasant tone!
22
+ """
23
+
24
+ user_template = """{input}
25
+ Think through your response step by step.
26
+ """
27
+
28
+
29
+ @cl.on_chat_start # marks a function that will be executed at the start of a user session
30
+ async def start_chat():
31
+ settings = {
32
+ "model": "gpt-3.5-turbo",
33
+ "temperature": 0,
34
+ "max_tokens": 500,
35
+ "top_p": 1,
36
+ "frequency_penalty": 0,
37
+ "presence_penalty": 0,
38
+ }
39
+
40
+ cl.user_session.set("settings", settings)
41
+
42
+
43
+ @cl.on_message # marks a function that should be run each time the chatbot receives a message from a user
44
+ async def main(message: cl.Message):
45
+ settings = cl.user_session.get("settings")
46
+
47
+ # client = AsyncOpenAI()
48
+ client = ChatOpenAI()
49
+
50
+ print(message.content)
51
+
52
+
53
+ response = retrieval_augmented_qa_pipeline(client).run_pipeline(message.content)
54
+
55
+ msg = cl.Message(content="")
56
+ msg.stream_token(response)
57
+
58
+ # Update the prompt object with the completion
59
+ msg.prompt = response
60
+
61
+ # Send and close the message stream
62
+ await msg.send()
data/KingLear.txt ADDED
The diff for this file is too large to render. See raw diff
 
rag.py ADDED
@@ -0,0 +1,80 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ from aimakerspace.text_utils import TextFileLoader, CharacterTextSplitter
2
+ from aimakerspace.vectordatabase import VectorDatabase
3
+ from aimakerspace.openai_utils.prompts import (
4
+ UserRolePrompt,
5
+ SystemRolePrompt,
6
+ AssistantRolePrompt,
7
+ )
8
+ from aimakerspace.openai_utils.chatmodel import ChatOpenAI
9
+
10
+ import asyncio
11
+ import nest_asyncio
12
+ nest_asyncio.apply()
13
+
14
+
15
+ TEXT_DOCUMENTS = [
16
+ "data/KingLear.txt",
17
+ ]
18
+
19
+ RAQA_PROMPT_TEMPLATE = """
20
+ Use the provided context to answer the user's query.
21
+
22
+ You may not answer the user's query unless there is specific context in the following text.
23
+
24
+ If you do not know the answer, or cannot answer, please respond with "I don't know".
25
+
26
+ Context:
27
+ {context}
28
+ """
29
+
30
+ raqa_prompt = SystemRolePrompt(RAQA_PROMPT_TEMPLATE)
31
+
32
+ USER_PROMPT_TEMPLATE = """
33
+ User Query:
34
+ {user_query}
35
+ """
36
+
37
+ user_prompt = UserRolePrompt(USER_PROMPT_TEMPLATE)
38
+
39
+ class RetrievalAugmentedQAPipeline:
40
+ def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
41
+ self.llm = llm
42
+ self.vector_db_retriever = vector_db_retriever
43
+
44
+ def run_pipeline(self, user_query: str) -> str:
45
+ context_list = self.vector_db_retriever.search_by_text(user_query, k=4)
46
+
47
+ context_prompt = ""
48
+ for context in context_list:
49
+ context_prompt += context[0] + "\n"
50
+
51
+ formatted_system_prompt = raqa_prompt.create_message(context=context_prompt)
52
+
53
+ formatted_user_prompt = user_prompt.create_message(user_query=user_query)
54
+
55
+ return self.llm.run([formatted_system_prompt, formatted_user_prompt])
56
+
57
+ def _split_documents():
58
+ split_documents = []
59
+ for doc in TEXT_DOCUMENTS:
60
+ # Load the text file
61
+ loader = TextFileLoader(doc)
62
+ documents = loader.load_documents()
63
+ # Split the text file into characters
64
+ splitter = CharacterTextSplitter()
65
+ split_documents.extend(splitter.split_texts(documents))
66
+
67
+ return split_documents
68
+
69
+ def _build_vector_db():
70
+ vector_db = VectorDatabase()
71
+ split_documents = _split_documents()
72
+ vector_db = asyncio.run(vector_db.abuild_from_list(split_documents))
73
+ return vector_db
74
+
75
+ def retrieval_augmented_qa_pipeline(client):
76
+ vector_db = _build_vector_db()
77
+ pipeline = RetrievalAugmentedQAPipeline(
78
+ llm=client,
79
+ vector_db_retriever=vector_db)
80
+ return pipeline