simonbb 0.0.1__tar.gz → 0.0.2__tar.gz

{simonbb-0.0.1 → simonbb-0.0.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: simonbb
-Version: 0.0.1
-Summary: A small package for teaching deep learning
+Version: 0.0.2
+Summary: A small package for teaching AI/ML courses
 Project-URL: Homepage, https://simonbb.com
 Project-URL: Issues, https://simonbb.com/issues
 Author-email: Huaxia Rui <huaxia.rui@simon.rochester.edu>

{simonbb-0.0.1 → simonbb-0.0.2}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simonbb"
-version = "0.0.1"
+version = "0.0.2"
 authors = [
   { name="Huaxia Rui", email="huaxia.rui@simon.rochester.edu" },
 ]
-description = "A small package for teaching deep learning"
+description = "A small package for teaching AI/ML courses"
 readme = "README.md"
 requires-python = ">=3.9"
 classifiers = [

{simonbb-0.0.1/src/simonbb → simonbb-0.0.2/src/simonbb/cis433}/utils.py

@@ -481,6 +481,4 @@ if __name__ == "__main__":
     print(encoded)
     print(vectorizer.vocab)
     print(vectorizer.word_to_idx)
-    print(vectorizer.idx_to_word)
-else:
-    print(f'Importing from local file "{__name__}.py"')
+    print(vectorizer.idx_to_word)

simonbb-0.0.2/src/simonbb/cis438/agentic.py

@@ -0,0 +1,259 @@
+import os
+import re
+from typing import Annotated, Literal, TypedDict, get_args
+
+from functools import partial
+
+import torch
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+from langchain_core.documents import Document
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnableLambda
+
+from langgraph.graph import END, START, StateGraph
+from langgraph.graph.message import add_messages
+
+from langchain_chroma import Chroma
+from langchain_huggingface import HuggingFaceEmbeddings
+
+from sentence_transformers import CrossEncoder
+
+vstore_path = f'{os.getenv("HOME")}/vstore'
+embedding_model = HuggingFaceEmbeddings(
+    model_name="BAAI/bge-large-en-v1.5",
+    model_kwargs={'device': device},
+    encode_kwargs={'normalize_embeddings': False}
+)   
+
+#%%
+
+def load_documents(path):
+    """Load documents from a file or directory."""
+    from langchain_community.document_loaders import PyPDFLoader, UnstructuredHTMLLoader
+
+    docs = []
+    success_cnt = 0
+    page_cnt = 0
+
+    if os.path.isfile(path):
+        filename = os.path.basename(path)
+        print(filename)
+        ext = filename.lower()
+        if ext.endswith('.pdf'):
+            documents = PyPDFLoader(path).load()
+        elif ext.endswith(('.html', '.ejs')):
+            documents = UnstructuredHTMLLoader(path).load()
+        else:
+            print(f"Unsupported file type: {filename}")
+            return None, 0, 0
+        success_cnt = 1
+        page_cnt = len(documents)
+        docs.extend(documents)
+    elif os.path.isdir(path):
+        for filename in os.listdir(path):
+            file = os.path.join(path, filename)
+            if not os.path.isfile(file):
+                continue
+            print(filename)
+            ext = filename.lower()
+            if ext.endswith('.pdf'):
+                documents = PyPDFLoader(file).load()
+            elif ext.endswith(('.html', '.ejs')):
+                documents = UnstructuredHTMLLoader(file).load()
+            else:
+                continue
+            success_cnt += 1
+            page_cnt += len(documents)
+            docs.extend(documents)
+    else:
+        print(f"Error: '{path}' is not a valid file or directory")
+        return None, 0, 0
+
+    if success_cnt == 0:
+        print("No valid documents found!")
+        return None, 0, 0
+
+    return docs, success_cnt, page_cnt
+
+reranker_model = CrossEncoder("BAAI/bge-reranker-large")
+def _getRetriever( knowledge_base, query_llm=None, k=3 ):
+    store = Chroma( persist_directory=f'{vstore_path}/{knowledge_base}/BAAI_db/chroma_vector_store', embedding_function=embedding_model )
+    base_retriever = store.as_retriever(search_kwargs={"k": k}) # a vector store becomes a retriever through the as_retriever() method       
+    if query_llm==None:
+        return base_retriever
+
+    perspectives_prompt = ChatPromptTemplate.from_template(
+    """You are an AI language model assistant. Your task is to generate 5 different versions of the given original question
+    These should be in 5 lines and provide ONLY these alternative questions separated by newlines, no explaination is needed.
+    Original question: {question}""")
+    def parse_queries_output(message):
+        #print( message.content )
+        return message.content.split('\n')
+    
+    query_gen = perspectives_prompt | query_llm | parse_queries_output
+    
+    def get_unique_union(document_lists): # Flatten list of lists, and deduplicate them
+        deduped_docs = { doc.page_content: doc for sublist in document_lists for doc in sublist}
+        unique_docs = list(deduped_docs.values()) # a flat list of unique docs        
+        return unique_docs
+   
+    def rerank_docs(query, docs, top_n=3):
+        """Rerank documents using cross-encoder and return top_n."""
+        if not docs:
+            return []
+        pairs = [(query, doc.page_content) for doc in docs]
+        scores = reranker_model.predict(pairs)
+        scored_docs = sorted(zip(scores, docs), key=lambda x: float(x[0]), reverse=True)
+        return [doc for _, doc in scored_docs[:top_n]]
+    
+    def retrieve_and_rerank(query):
+        # Generate alternative queries + include original
+        alt_queries = query_gen.invoke({"question": query})
+        all_queries = [query] + alt_queries
+        # Retrieve chunks for each query
+        doc_lists = base_retriever.batch(all_queries)
+        unique_docs = get_unique_union(doc_lists)
+        # Rerank with cross-encoder and return top 3
+        return rerank_docs(query, unique_docs, top_n=5)
+
+    return RunnableLambda(retrieve_and_rerank)
+    
+
+"""
+RAG Chain
+"""
+
+def getRagModel(knowledge_base, llm, query_llm=None, k=3):
+    """
+    Create and return a RAG model that returns a dictionary with 'result' and 'source_documents'.
+    """
+    retriever = _getRetriever(knowledge_base, query_llm, k)
+
+    def _rag_chain(input_dict):
+        query = input_dict["query"]
+        docs = retriever.invoke(query)
+        snippets = []
+        for i, doc in enumerate(docs, start=1):            
+            snippets.append(f"Snippet {i}: {doc.page_content}")
+        context = "\n".join(snippets)        
+        system_prompt = """You are a helpful assistant answering questions based on provided document snippets.
+       IMPORTANT INSTRUCTIONS:
+       1. Base your answer ONLY on the provided context snippets below.
+       2. Synthesize information from multiple snippets if needed.
+       3. If the snippets contain partial information, provide the best answer you can with what's available.
+       4. Only say "There wasn't enough information to answer the question" if the snippets truly contain NO relevant information.
+       5. Always cite your sources using the snippet numbers in parentheses, like (1), (2), etc.
+
+       The snippets are provided in this format:
+       Snippet 1: <text content>
+       Snippet 2: <text content>
+       ...
+
+       {context}"""
+        prompt = ChatPromptTemplate.from_messages( [ ("system", system_prompt),  ("human", "{query}")  ])
+        messages = prompt.format_messages( context=context, query=query )
+        answer = llm.invoke(messages).content
+        return {"answer": answer, "sources": docs}
+
+    return RunnableLambda(_rag_chain)
+
+
+"""
+multi-rag system with router
+"""
+
+domain_prompt = """You are a helpful assistant answering questions based on provided document snippets relating to {domain}.
+
+IMPORTANT INSTRUCTIONS:
+1. Base your answer ONLY on the provided context snippets below.
+2. Synthesize information from multiple snippets if needed.
+3. If the snippets contain partial information, provide the best answer you can with what's available.
+4. Only say "There wasn't enough information to answer the question" if the snippets truly contain NO relevant information.
+5. Always cite your sources using the snippet numbers in parentheses, like (1), (2), etc.
+
+The snippets are provided in this format:
+Snippet 1: <text content>
+Snippet 2: <text content>
+...
+
+{context}"""
+
+def multiRagBuilder( domain_literals, router_prompt, chat_router, chat, query_llm=None, k=3):
+    """
+    domain_literals: the last one is a placeholder if the router finds no domain matches the query
+    """
+    domains = get_args(domain_literals)[:-1] # exclude the placeholder
+    nodomain = get_args(domain_literals)[-1]
+    
+    class State(TypedDict):    
+        messages: Annotated[list, add_messages] # annotated with the reducer function to append new messages to the existing list, rather than overwriting
+        query: str # input
+        domain: domain_literals # output
+        documents: list[Document]
+        answer: str
+
+    class Input(TypedDict):
+        query: str
+
+    class Output(TypedDict):
+        domain: domain_literals
+        documents: list[Document]
+        answer: str
+    
+    def router_node(state: State) -> State:
+        user_message = HumanMessage(state["query"])
+        messages = [ SystemMessage(router_prompt), *state["messages"], user_message ]
+        res = chat_router.invoke(messages)
+        return {
+            "domain": res.content.strip(),
+            "messages": [user_message, res], # update conversation history
+        }
+
+    def pick_retriever( state: State) -> Literal[*domains, "generate_answer"]:
+        for domain in domains:
+            if re.search( domain, state['domain'] ):
+                return domain
+        return 'generate_answer'
+    
+    def generate_answer(state: State) -> State:    
+        snippets = []    
+        for i, doc in enumerate(state.get('documents', []), start=1):
+            snippets.append(f"Snippet {i}: {doc.page_content}")       
+        context = "\n".join(snippets)
+        if state.get('domain', '')!=nodomain:
+            prompt = ChatPromptTemplate.from_messages( [ ("system", domain_prompt),  ("human", "{query}")  ])
+            messages = prompt.format_messages( domain=state.get('domain', ''), context=context, query=state["query"] )
+        else:
+            prompt = ChatPromptTemplate.from_messages( [ ("system", 'You are a helpful assistant.'),  ("human", "{query}")  ])
+            messages = prompt.format_messages( query=state["query"] )
+        res = chat.invoke(messages)
+        return {
+            "answer": res.content,
+            "messages": res,  # update conversation history
+        }
+    
+    def retriever_node( domain: domains, state: State):        
+        query = re.sub(domain, 'this class', state["query"] ) # using the course code hurts RAG since the course code is rarely used in documents.
+        #print( f"domain={domain}; query={query}")
+        documents = retrievers[domain].invoke( query )
+        return { "documents": documents, 'query': query }
+    
+    builder = StateGraph(State, input_schema=Input, output_schema=Output)
+    builder.add_node("router", router_node)
+    builder.add_edge(START, "router")
+    builder.add_conditional_edges("router", pick_retriever)
+
+    retrievers = {}
+    retriever_nodes = {}
+    for domain in domains:
+        retrievers[domain] = _getRetriever(domain, query_llm, k)
+        retriever_nodes[domain] = partial( retriever_node, domain ) # the 1st argument is the partial function. the rest are frozen arguments passed positionally to fill the leftmost parameters of the original function.
+        builder.add_node(domain, retriever_nodes[domain])
+        builder.add_edge(domain, "generate_answer")
+        
+    builder.add_node("generate_answer", generate_answer)
+    builder.add_edge("generate_answer", END)
+    
+    return builder