simonbb 0.0.2__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.2 → 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.2 → 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.2 → 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 )

{simonbb-0.0.2 → simonbb-0.0.3}/src/simonbb/cis438/agentic.py

@@ -1,3 +1,6 @@
+# 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
@@ -17,10 +20,9 @@ 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
 
-vstore_path = f'{os.getenv("HOME")}/vstore'
 embedding_model = HuggingFaceEmbeddings(
     model_name="BAAI/bge-large-en-v1.5",
     model_kwargs={'device': device},
@@ -30,8 +32,7 @@ embedding_model = HuggingFaceEmbeddings(
 #%%
 
 def load_documents(path):
-    """Load documents from a file or directory."""
-    from langchain_community.document_loaders import PyPDFLoader, UnstructuredHTMLLoader
+    """Load documents from a file or directory."""    
 
     docs = []
     success_cnt = 0
@@ -78,7 +79,7 @@ def load_documents(path):
     return docs, success_cnt, page_cnt
 
 reranker_model = CrossEncoder("BAAI/bge-reranker-large")
-def _getRetriever( knowledge_base, query_llm=None, k=3 ):
+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:

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.2/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.4
-Name: simonbb
-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>
-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.2/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.2/pyproject.toml

@@ -1,23 +0,0 @@
-[build-system]
-requires = ["hatchling >= 1.26"]
-build-backend = "hatchling.build"
-
-[project]
-name = "simonbb"
-version = "0.0.2"
-authors = [
-  { name="Huaxia Rui", email="huaxia.rui@simon.rochester.edu" },
-]
-description = "A small package for 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*"]
-
-[project.urls]
-Homepage = "https://simonbb.com"
-Issues = "https://simonbb.com/issues"