simonbb 0.0.1__tar.gz → 0.0.3__tar.gz

simonbb-0.0.3/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: simonbb
+Version: 0.0.3
+Summary: A small package to facilitate teaching AI/ML courses
+Project-URL: Homepage, https://simonbb.com
+Author-email: Huaxia Rui <huaxia.rui@simon.rochester.edu>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: langchain-chroma~=1.1.0
+Requires-Dist: langchain-community~=0.4.1
+Requires-Dist: langchain-core~=1.2.23
+Requires-Dist: langchain-huggingface~=1.2.1
+Requires-Dist: langchain~=1.2.13
+Requires-Dist: langgraph~=1.1.3
+Requires-Dist: matplotlib~=3.10.8
+Requires-Dist: numpy~=2.4.0
+Requires-Dist: sentence-transformers~=5.3.0
+Requires-Dist: torchvision~=0.24.1
+Requires-Dist: torch~=2.9.1
+Requires-Dist: transformers~=4.57.3
+Description-Content-Type: text/markdown
+
+# Background
+
+This is a pet project out of my own teaching needs at University of Rochester.
+I mainly teach these 2 courses to MBA/MS students who lack technical background.
+
+- CIS 433: AI and Deep Learning
+- CIS 438: Agentic AI Applications
+
+Accordingly, this package contains 2 modules.
+
+- `simonbb.cis433`: this module is useful for anyone teacheing deep learning using PyTorch but doesn't want to bother students with too much nitty-gritty details.
+- `simonbb.cis438`: this module is useful for anyone who teaches agentic AI using langchain.
+

simonbb-0.0.3/README.md

@@ -0,0 +1,13 @@
+# Background
+
+This is a pet project out of my own teaching needs at University of Rochester.
+I mainly teach these 2 courses to MBA/MS students who lack technical background.
+
+- CIS 433: AI and Deep Learning
+- CIS 438: Agentic AI Applications
+
+Accordingly, this package contains 2 modules.
+
+- `simonbb.cis433`: this module is useful for anyone teacheing deep learning using PyTorch but doesn't want to bother students with too much nitty-gritty details.
+- `simonbb.cis438`: this module is useful for anyone who teaches agentic AI using langchain.
+

simonbb-0.0.3/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "simonbb"
+version = "0.0.3"
+authors = [
+	{ name="Huaxia Rui", email="huaxia.rui@simon.rochester.edu" },
+]
+description = "A small package to facilitate teaching AI/ML courses"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+	"Programming Language :: Python :: 3",
+	"Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+	"matplotlib~=3.10.8",
+	"torch~=2.9.1",
+	"torchvision~=0.24.1",
+	"numpy~=2.4.0",
+	"transformers~=4.57.3",
+	"langchain-core~=1.2.23",
+	"langchain~=1.2.13",
+	"langgraph~=1.1.3",
+	"langchain-community~=0.4.1",
+	"langchain-chroma~=1.1.0",
+	"langchain-huggingface~=1.2.1",
+	"sentence-transformers~=5.3.0",
+]
+[project.urls]
+Homepage = "https://simonbb.com"

{simonbb-0.0.1/src/simonbb → simonbb-0.0.3/src/simonbb/cis433}/gpt.py

@@ -198,7 +198,4 @@ if __name__ == "__main__":
     out = generate( model=model, idx=encoded_tensor, max_new_tokens=6, context_size=cfg["context_length"] )
 
     print("Output:", out)
-    print( tokenizer.decode(out.squeeze(0).tolist()) )
-    
-else: 
-    print(f'GPT imported from local file "{__name__}.py"')
+    print( tokenizer.decode(out.squeeze(0).tolist()) )

{simonbb-0.0.1/src/simonbb → simonbb-0.0.3/src/simonbb/cis433}/transformer.py

@@ -209,7 +209,7 @@ class Transformer(nn.Module):
         return self.final_layer(x)  # (batch_size, target_len, tgt_vocab_size)
 
 
-#%% Sanity Check: run from the parent folder of rui as "python -m rui.torch.transformer" since we used relative import
+#%% Sanity Check: run from the parent folder of simonbb as "python -m simonbb.cis433.transformer" since we used relative import
 if __name__ == "__main__":
     
     from ..utils import TextVectorizer
@@ -248,6 +248,4 @@ if __name__ == "__main__":
     decoder.eval()
     with torch.no_grad():
         print(f"Encoder output shape: {encoder(x).shape}")
-        print(f"Decoder output shape: {decoder(x=x, context=x).shape}")
-else:
-    print(f'Transformer imported from local file "{__name__}.py"')
+        print(f"Decoder output shape: {decoder(x=x, context=x).shape}")

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

@@ -5,174 +5,15 @@ A collection of utility functions for teaching deep learning
 
 import os
 import time
-import numpy as np
 import copy
-import re
-import pickle
-import json
-from collections import Counter
-import urllib.request
 
+import numpy as np
 import matplotlib.pyplot as plt
-
 import torch
 import torch.nn as nn
 
 #%%
 
-class TextVectorizer:
-    def __init__(self, max_tokens=20000, output_mode="int", output_sequence_length=None, ngrams=None, standardize=None):
-        self.max_tokens = max_tokens
-        self.output_mode = output_mode
-        self.output_sequence_length = output_sequence_length
-        self.ngrams = ngrams
-        self.standardize = standardize
-        self.vocab = None
-        self.word_to_idx = None
-        self.idx_to_word = None
-        self.idf_weights = None
-
-    def _tokenize(self, text):
-        if self.standardize:
-            text = self.standardize(text)
-        else:
-            text = text.lower()
-            text = re.sub(r'[^\w\s]', ' ', text)
-        tokens = text.split()
-        if self.ngrams and self.ngrams >= 2:
-            ngram_tokens = []
-            for n in range(1, self.ngrams + 1):
-                for i in range( len(tokens) - n + 1 ):
-                    ngram_tokens.append(' '.join(tokens[i:i + n]))
-            return ngram_tokens
-        return tokens
-
-    def adapt(self, texts):
-        """Build vocabulary from texts"""
-        token_counter = Counter()
-        doc_freq = Counter()  # for TF-IDF
-        num_docs = 0
-        print("Adapting TextVectorizer...")
-        for text in texts:
-            num_docs += 1
-            tokens = self._tokenize(text)
-            token_counter.update(tokens)
-            doc_freq.update(set(tokens))
-        # Reserve 0 for padding, 1 for unknown, hence minus 2 to account for them.
-        most_common = token_counter.most_common(self.max_tokens - 2 if self.max_tokens else None) # most_common(n=None) returns all elements in the counter if n is omitted or None.
-        self.vocab = ['<pad>', '<unk>'] + [word for word, _ in most_common] # 0 for padding, 1 for unknown
-        self.word_to_idx = {word: idx for idx, word in enumerate(self.vocab)}
-        self.idx_to_word = {idx: word for idx, word in enumerate(self.vocab)}
-        # Compute IDF weights for tf-idf mode
-        if self.output_mode == "tf_idf":
-            self.idf_weights = np.zeros(len(self.vocab))
-            for word, idx in self.word_to_idx.items():
-                df = doc_freq.get(word, 0) + 1  # add 1 for smoothing
-                self.idf_weights[idx] = np.log(num_docs / df) + 1
-        print(f"Vocabulary size: {len(self.vocab)}")
-
-    def __call__(self, texts):
-        if isinstance(texts, str):
-            texts = [texts]
-        if self.output_mode == "int":
-            return self._vectorize_int(texts)
-        elif self.output_mode == "multi_hot":
-            return self._vectorize_multi_hot(texts)
-        elif self.output_mode == "tf_idf":
-            return self._vectorize_tfidf(texts)
-
-    def _vectorize_int(self, texts):
-        batch_indices = []
-        for text in texts:
-            tokens = self._tokenize(text)
-            indices = [self.word_to_idx.get(t, 1) for t in tokens]  # 1 is <unk>
-            if self.output_sequence_length:
-                if len(indices) < self.output_sequence_length:
-                    indices = indices + [0] * (self.output_sequence_length - len(indices))
-                else:
-                    indices = indices[:self.output_sequence_length]
-            batch_indices.append(indices)
-        return np.array(batch_indices)
-
-    def _vectorize_multi_hot(self, texts):
-        result = np.zeros( (len(texts), len(self.vocab)), dtype=np.float32 )
-        for i, text in enumerate(texts):
-            tokens = self._tokenize(text)
-            for t in tokens:
-                idx = self.word_to_idx.get(t, 1)
-                if idx < len(self.vocab):
-                    result[i, idx] = 1
-        return result
-
-    def _vectorize_tfidf(self, texts):
-        result = np.zeros( (len(texts), len(self.vocab)), dtype=np.float32 )
-        for i, text in enumerate(texts):
-            tokens = self._tokenize(text)
-            tf = Counter(tokens)
-            for t, count in tf.items():
-                idx = self.word_to_idx.get(t, 1)
-                if idx < len(self.vocab):
-                    result[i, idx] = count * self.idf_weights[idx]
-        return result
-
-    def get_vocabulary(self):
-        return self.vocab
-    
-    def save(self, path):
-        vec = {'max_tokens': self.max_tokens, 'output_sequence_length': self.output_sequence_length,
-               'vocab': self.vocab, 'word_to_idx': self.word_to_idx, 'idx_to_word': self.idx_to_word,
-               'has_standardizer': self.standardize is not None}
-        with open(path, 'wb') as f:
-            pickle.dump(vec, f)
-            
-    # transforms a method into a class method (i.e., bound to the class rather than an individual instance)
-    @classmethod
-    def load(cls, path, standardize=None):
-        data = pickle.load(path, weights_only=False)
-        vectorizer = cls( max_tokens=data['max_tokens'], output_sequence_length=data['output_sequence_length'], 
-                          standardize=standardize if data.get('has_standardize') else None )
-        vectorizer.vocab = data['vocab']
-        vectorizer.word_to_idx = data['word_to_idx']
-        vectorizer.idx_to_word = data['idx_to_word']
-        return vectorizer
-
-
-def query_ollama(prompt, model="llama3", url="http://localhost:11434/api/chat"):
-    # Create the data payload as a dictionary
-    data = {
-        "model": model,
-        "messages": [
-            {"role": "user", "content": prompt}
-        ],
-        "options": {     # Settings below are required for deterministic responses
-            "seed": 123,
-            "temperature": 0,
-            "num_ctx": 2048
-        }
-    }
-
-    # Convert the dictionary to a JSON formatted string and encode it to bytes
-    payload = json.dumps(data).encode("utf-8")
-
-    # Create a request object, setting the method to POST and adding necessary headers
-    request = urllib.request.Request(url, data=payload, method="POST")
-    request.add_header("Content-Type", "application/json")
-
-    # Send the request and capture the response
-    response_data = ""
-    with urllib.request.urlopen(request) as response:
-        # Read and decode the response
-        while True:
-            line = response.readline().decode("utf-8")
-            if not line:
-                break
-            response_json = json.loads(line)
-            response_data += response_json["message"]["content"]
-
-    return response_data
-
-#%%
-
 class ModelCheckpoint:
     def __init__(self, filepath, monitor="val_loss", save_best_only=True, save_optimizer_state=False):
         self.filepath = filepath
@@ -470,10 +311,12 @@ def evaluate(model, loader, device, loss_fn=nn.CrossEntropyLoss(), accuracy_fn=N
         val_accuracy = val_accuracy.item() # extract the value of a single-item tensor 
     return {'loss':val_loss, 'accuracy':val_accuracy}
 
-#%%
+#%% Sanity Check: run from the parent folder of simonbb as "python -m simonbb.cis433.utils" since we used relative import
 
 if __name__ == "__main__":
     
+    from ..utils import TextVectorizer
+    
     vectorizer = TextVectorizer( max_tokens=10, output_mode="int" )
     txts = ['how are you']
     vectorizer.adapt( txts )
@@ -481,6 +324,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.3/src/simonbb/cis438/agentic.py

@@ -0,0 +1,260 @@
+# module dependencies: torch torchvision langchain_core langchain langgraph langchain_community langchain_chroma langchain_huggingface sentence_transformers
+# additional packages for class projects: langchain_ollama langchain_text_splitters unstructured streamlit_javascript
+
+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 langchain_community.document_loaders import PyPDFLoader, UnstructuredHTMLLoader
+from sentence_transformers import CrossEncoder
+
+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."""    
+
+    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, vstore_path = f'{os.getenv("HOME")}/vstore' ):
+    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

simonbb-0.0.3/src/simonbb/utils.py

@@ -0,0 +1,158 @@
+import re
+import pickle
+import json
+from collections import Counter
+import urllib.request
+import numpy as np
+
+
+class TextVectorizer:
+    def __init__(self, max_tokens=20000, output_mode="int", output_sequence_length=None, ngrams=None, standardize=None):
+        self.max_tokens = max_tokens
+        self.output_mode = output_mode
+        self.output_sequence_length = output_sequence_length
+        self.ngrams = ngrams
+        self.standardize = standardize
+        self.vocab = None
+        self.word_to_idx = None
+        self.idx_to_word = None
+        self.idf_weights = None
+
+    def _tokenize(self, text):
+        if self.standardize:
+            text = self.standardize(text)
+        else:
+            text = text.lower()
+            text = re.sub(r'[^\w\s]', ' ', text)
+        tokens = text.split()
+        if self.ngrams and self.ngrams >= 2:
+            ngram_tokens = []
+            for n in range(1, self.ngrams + 1):
+                for i in range( len(tokens) - n + 1 ):
+                    ngram_tokens.append(' '.join(tokens[i:i + n]))
+            return ngram_tokens
+        return tokens
+
+    def adapt(self, texts):
+        """Build vocabulary from texts"""
+        token_counter = Counter()
+        doc_freq = Counter()  # for TF-IDF
+        num_docs = 0
+        print("Adapting TextVectorizer...")
+        for text in texts:
+            num_docs += 1
+            tokens = self._tokenize(text)
+            token_counter.update(tokens)
+            doc_freq.update(set(tokens))
+        # Reserve 0 for padding, 1 for unknown, hence minus 2 to account for them.
+        most_common = token_counter.most_common(self.max_tokens - 2 if self.max_tokens else None) # most_common(n=None) returns all elements in the counter if n is omitted or None.
+        self.vocab = ['<pad>', '<unk>'] + [word for word, _ in most_common] # 0 for padding, 1 for unknown
+        self.word_to_idx = {word: idx for idx, word in enumerate(self.vocab)}
+        self.idx_to_word = {idx: word for idx, word in enumerate(self.vocab)}
+        # Compute IDF weights for tf-idf mode
+        if self.output_mode == "tf_idf":
+            self.idf_weights = np.zeros(len(self.vocab))
+            for word, idx in self.word_to_idx.items():
+                df = doc_freq.get(word, 0) + 1  # add 1 for smoothing
+                self.idf_weights[idx] = np.log(num_docs / df) + 1
+        print(f"Vocabulary size: {len(self.vocab)}")
+
+    def __call__(self, texts):
+        if isinstance(texts, str):
+            texts = [texts]
+        if self.output_mode == "int":
+            return self._vectorize_int(texts)
+        elif self.output_mode == "multi_hot":
+            return self._vectorize_multi_hot(texts)
+        elif self.output_mode == "tf_idf":
+            return self._vectorize_tfidf(texts)
+
+    def _vectorize_int(self, texts):
+        batch_indices = []
+        for text in texts:
+            tokens = self._tokenize(text)
+            indices = [self.word_to_idx.get(t, 1) for t in tokens]  # 1 is <unk>
+            if self.output_sequence_length:
+                if len(indices) < self.output_sequence_length:
+                    indices = indices + [0] * (self.output_sequence_length - len(indices))
+                else:
+                    indices = indices[:self.output_sequence_length]
+            batch_indices.append(indices)
+        return np.array(batch_indices)
+
+    def _vectorize_multi_hot(self, texts):
+        result = np.zeros( (len(texts), len(self.vocab)), dtype=np.float32 )
+        for i, text in enumerate(texts):
+            tokens = self._tokenize(text)
+            for t in tokens:
+                idx = self.word_to_idx.get(t, 1)
+                if idx < len(self.vocab):
+                    result[i, idx] = 1
+        return result
+
+    def _vectorize_tfidf(self, texts):
+        result = np.zeros( (len(texts), len(self.vocab)), dtype=np.float32 )
+        for i, text in enumerate(texts):
+            tokens = self._tokenize(text)
+            tf = Counter(tokens)
+            for t, count in tf.items():
+                idx = self.word_to_idx.get(t, 1)
+                if idx < len(self.vocab):
+                    result[i, idx] = count * self.idf_weights[idx]
+        return result
+
+    def get_vocabulary(self):
+        return self.vocab
+    
+    def save(self, path):
+        vec = {'max_tokens': self.max_tokens, 'output_sequence_length': self.output_sequence_length,
+               'vocab': self.vocab, 'word_to_idx': self.word_to_idx, 'idx_to_word': self.idx_to_word,
+               'has_standardizer': self.standardize is not None}
+        with open(path, 'wb') as f:
+            pickle.dump(vec, f)
+            
+    # transforms a method into a class method (i.e., bound to the class rather than an individual instance)
+    @classmethod
+    def load(cls, path, standardize=None):
+        data = pickle.load(path, weights_only=False)
+        vectorizer = cls( max_tokens=data['max_tokens'], output_sequence_length=data['output_sequence_length'], 
+                          standardize=standardize if data.get('has_standardize') else None )
+        vectorizer.vocab = data['vocab']
+        vectorizer.word_to_idx = data['word_to_idx']
+        vectorizer.idx_to_word = data['idx_to_word']
+        return vectorizer
+
+
+def query_ollama(prompt, model="llama3", url="http://localhost:11434/api/chat"):
+    # Create the data payload as a dictionary
+    data = {
+        "model": model,
+        "messages": [
+            {"role": "user", "content": prompt}
+        ],
+        "options": {     # Settings below are required for deterministic responses
+            "seed": 123,
+            "temperature": 0,
+            "num_ctx": 2048
+        }
+    }
+
+    # Convert the dictionary to a JSON formatted string and encode it to bytes
+    payload = json.dumps(data).encode("utf-8")
+
+    # Create a request object, setting the method to POST and adding necessary headers
+    request = urllib.request.Request(url, data=payload, method="POST")
+    request.add_header("Content-Type", "application/json")
+
+    # Send the request and capture the response
+    response_data = ""
+    with urllib.request.urlopen(request) as response:
+        # Read and decode the response
+        while True:
+            line = response.readline().decode("utf-8")
+            if not line:
+                break
+            response_json = json.loads(line)
+            response_data += response_json["message"]["content"]
+
+    return response_data

simonbb-0.0.1/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.4
-Name: simonbb
-Version: 0.0.1
-Summary: A small package for teaching deep learning
-Project-URL: Homepage, https://simonbb.com
-Project-URL: Issues, https://simonbb.com/issues
-Author-email: Huaxia Rui <huaxia.rui@simon.rochester.edu>
-License-Expression: MIT
-License-File: LICENSE
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-
-# What's this package for?
-Anyone who teaches deep learning using PyTorch but doesn't want to bother students with too much nitty-gritty details.

simonbb-0.0.1/README.md

@@ -1,2 +0,0 @@
-# What's this package for?
-Anyone who teaches deep learning using PyTorch but doesn't want to bother students with too much nitty-gritty details.

simonbb-0.0.1/pyproject.toml

@@ -1,23 +0,0 @@
-[build-system]
-requires = ["hatchling >= 1.26"]
-build-backend = "hatchling.build"
-
-[project]
-name = "simonbb"
-version = "0.0.1"
-authors = [
-  { name="Huaxia Rui", email="huaxia.rui@simon.rochester.edu" },
-]
-description = "A small package for teaching deep learning"
-readme = "README.md"
-requires-python = ">=3.9"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "Operating System :: OS Independent",
-]
-license = "MIT"
-license-files = ["LICEN[CS]E*"]
-
-[project.urls]
-Homepage = "https://simonbb.com"
-Issues = "https://simonbb.com/issues"