simonbb 0.0.6__tar.gz → 0.0.8__tar.gz

{simonbb-0.0.6 → simonbb-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: simonbb
-Version: 0.0.6
+Version: 0.0.8
 Summary: A small package to facilitate teaching AI courses at business schools
 Project-URL: Homepage, https://simonbb.com
 Author-email: Huaxia Rui <huaxia.rui@simon.rochester.edu>
@@ -10,14 +10,9 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
 Requires-Dist: gymnasium~=1.3.0
-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: opencv-python~=5.0.0.93
 Requires-Dist: pytorch-ignite~=0.5.4
 Requires-Dist: pyyaml~=6.0.3
 Requires-Dist: ray~=2.56.0

{simonbb-0.0.6 → simonbb-0.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simonbb"
-version = "0.0.6"
+version = "0.0.8"
 authors = [
 	{ name="Huaxia Rui", email="huaxia.rui@simon.rochester.edu" },
 ]
@@ -23,17 +23,12 @@ dependencies = [
 	"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",
 	"gymnasium~=1.3.0",
 	"pytorch-ignite~=0.5.4",
 	"stable_baselines3~=2.9.0",
 	"ray~=2.56.0",
+	"opencv-python~=5.0.0.93",
 	"pyyaml~=6.0.3"
 ]
 [project.urls]

{simonbb-0.0.6 → simonbb-0.0.8}/src/simonbb/cis433/experience.py

@@ -25,28 +25,26 @@ class Experience:
 
 class ExperienceSource:
     """
-    Simple n-step experience source using single or multiple environments
+    n-step experience source using single or multiple environments
 
-    Every experience contains n list of Experience entries
+    Every experience contains a list of n Experience entries
     """
     Item = tt.Tuple[Experience, ...]
 
-    def __init__(self, env: gym.Env | tt.Collection[gym.Env], agent: BaseAgent,
-                 steps_count: int = 2, steps_delta: int = 1,
-                 env_seed: tt.Optional[int] = None):
+    def __init__(self, env: gym.Env | tt.Collection[gym.Env], agent: BaseAgent, steps_count: int = 2, steps_delta: int = 1, env_seed: tt.Optional[int] = None):
         """
         Create simple experience source
         :param env: environment or list of environments to be used
         :param agent: callable to convert batch of states into actions to take
         :param steps_count: count of steps to track for every experience chain
-        :param steps_delta: how many steps to do between experience items
+        :param steps_delta: how many steps to do between subjectory emissions
         :param env_seed: seed to be used in Env.reset() call
         """
         assert steps_count >= 1
         if isinstance(env, (list, tuple)):
             self.pool = env
             # do the check for the multiple copies passed
-            ids = set(id(e) for e in env)
+            ids = set(id(e) for e in env) # id() returns a unique, constant integer identifier for a specified object during its lifetime
             if len(ids) < len(env):
                 raise ValueError("You passed single environment instance multiple times")
         else:
@@ -54,7 +52,7 @@ class ExperienceSource:
         self.agent = agent
         self.steps_count = steps_count
         self.steps_delta = steps_delta
-        self.total_rewards = []
+        self.total_rewards = [] # simple sum of immediate rewards, without discounting
         self.total_steps = []
         self.agent_states = [agent.initial_state() for _ in self.pool]
         self.env_seed = env_seed
@@ -67,7 +65,7 @@ class ExperienceSource:
             else:
                 obs, _ = env.reset()
             states.append(obs)
-            histories.append(deque(maxlen=self.steps_count))
+            histories.append( deque(maxlen=self.steps_count) ) # Note the max length of the double-ended queue
             cur_rewards.append(0.0)
             cur_steps.append(0)
 
@@ -81,17 +79,16 @@ class ExperienceSource:
                 next_state, r, is_done, is_tr, _ = env.step(action)
                 cur_rewards[idx] += r
                 cur_steps[idx] += 1
-                history.append(Experience(state=state, action=action, reward=r, done_trunc=is_done or is_tr))
+                history.append(Experience(state=state, action=action, reward=r, done_trunc=is_done or is_tr)) # push out the oldest step once deque is full (i.e., steps_count reached)
                 if len(history) == self.steps_count and iter_idx % self.steps_delta == 0:
                     yield tuple(history)
                 states[idx] = next_state
                 if is_done or is_tr:
-                    # generate tail of history
                     if 0 < len(history) < self.steps_count:
                         yield tuple(history)
                     while len(history) > 1:
                         history.popleft()
-                        yield tuple(history)
+                        yield tuple(history) # a sub-trajectory of the history
                     self.total_rewards.append(cur_rewards[idx])
                     self.total_steps.append(cur_steps[idx])
                     cur_rewards[idx] = 0.0
@@ -104,13 +101,15 @@ class ExperienceSource:
                     history.clear()
             iter_idx += 1
 
+
+    # pop_total_rewards() returns a list of total rewards (without discounting), one per env, after an episode ends
     def pop_total_rewards(self) -> tt.List[float]:
         r = self.total_rewards
         if r:
             self.total_rewards = []
             self.total_steps = []
         return r
-
+    # pop_total_rewards() returns a list of total rewards (without discounting) and number of steps, one per env, after an episode ends
     def pop_rewards_steps(self) -> tt.List[tt.Tuple[float, int]]:
         res = list(zip(self.total_rewards, self.total_steps))
         if res:
@@ -148,12 +147,54 @@ class ExperienceSourceFirstLast(ExperienceSource):
             else:
                 last_state = exp[-1].state
                 elems = exp[:-1]
-            total_reward = 0.0
+            discounted_total_reward = 0.0
             for e in reversed(elems):
-                total_reward *= self.gamma
-                total_reward += e.reward
-            yield ExperienceFirstLast(state=exp[0].state, action=exp[0].action,
-                                      reward=total_reward, last_state=last_state)
+                discounted_total_reward *= self.gamma
+                discounted_total_reward += e.reward
+            yield ExperienceFirstLast(state=exp[0].state, action=exp[0].action, reward=discounted_total_reward, last_state=last_state)
+
+
+
+class ExperienceReplayBuffer:
+    def __init__(self, experience_source: tt.Optional[ExperienceSource], buffer_size: int):
+        self.experience_source_iter = None if experience_source is None else iter(experience_source)
+        self.buffer: tt.List[ExperienceSource.Item] = []
+        self.capacity = buffer_size
+        self.pos = 0
+
+    def __len__(self):
+        return len(self.buffer)
+
+    def __iter__(self) -> tt.Iterator[ExperienceSource.Item]:
+        return iter(self.buffer)
+
+    def sample(self, batch_size: int) -> tt.List[ExperienceSource.Item]:
+        """
+        Get one random batch from experience replay
+        :param batch_size: size of the batch to sample
+        :return: list of experience entries
+        """
+        if len(self.buffer) <= batch_size:
+            return self.buffer
+        # Warning: replace=False makes random.choice O(n)
+        keys = np.random.choice(len(self.buffer), batch_size, replace=True)
+        return [self.buffer[key] for key in keys]
+
+    def _add(self, sample: ExperienceSource.Item):
+        if len(self.buffer) < self.capacity:
+            self.buffer.append(sample)
+        else:
+            self.buffer[self.pos] = sample
+        self.pos = (self.pos + 1) % self.capacity
+
+    def populate(self, samples: int):
+        """
+        Populates samples into the buffer
+        :param samples: how many samples to populate
+        """
+        for _ in range(samples):
+            entry = next(self.experience_source_iter)
+            self._add(entry)
 
 
 def vector_rewards(rewards: tt.Deque[np.ndarray], dones: tt.Deque[np.ndarray], gamma: float) -> np.ndarray:
@@ -406,47 +447,6 @@ class ExperienceSourceBuffer:
             yield self.buffer[episode][ofs:ofs+self.steps_count]
 
 
-class ExperienceReplayBuffer:
-    def __init__(self, experience_source: tt.Optional[ExperienceSource], buffer_size: int):
-        self.experience_source_iter = None if experience_source is None else iter(experience_source)
-        self.buffer: tt.List[ExperienceSource.Item] = []
-        self.capacity = buffer_size
-        self.pos = 0
-
-    def __len__(self):
-        return len(self.buffer)
-
-    def __iter__(self) -> tt.Iterator[ExperienceSource.Item]:
-        return iter(self.buffer)
-
-    def sample(self, batch_size: int) -> tt.List[ExperienceSource.Item]:
-        """
-        Get one random batch from experience replay
-        :param batch_size: size of the batch to sample
-        :return: list of experience entries
-        """
-        if len(self.buffer) <= batch_size:
-            return self.buffer
-        # Warning: replace=False makes random.choice O(n)
-        keys = np.random.choice(len(self.buffer), batch_size, replace=True)
-        return [self.buffer[key] for key in keys]
-
-    def _add(self, sample: ExperienceSource.Item):
-        if len(self.buffer) < self.capacity:
-            self.buffer.append(sample)
-        else:
-            self.buffer[self.pos] = sample
-        self.pos = (self.pos + 1) % self.capacity
-
-    def populate(self, samples: int):
-        """
-        Populates samples into the buffer
-        :param samples: how many samples to populate
-        """
-        for _ in range(samples):
-            entry = next(self.experience_source_iter)
-            self._add(entry)
-
 
 class PrioReplayBufferNaive:
     def __init__(self, exp_source, buf_size, prob_alpha=0.6):

{simonbb-0.0.6 → simonbb-0.0.8}/src/simonbb/cis433/ignite.py

@@ -13,39 +13,38 @@ class EpisodeEvents(EventEnum):
 
 
 class EndOfEpisodeHandler:
-    def __init__(self, exp_source: ExperienceSource, alpha: float = 0.98,
-                 bound_avg_reward: Optional[float] = None,
-                 subsample_end_of_episode: Optional[int] = None):
+    def __init__(self, exp_source: ExperienceSource, alpha: float = 0.98, bound_avg_reward: Optional[float] = None, period: Optional[int] = None):
         """
-        Construct end-of-episode event handler
+        This end-of-episode event handler, triggered by Events.ITERATION_COMPLETED, fires an EPISODE_COMPLETED event for every episode, or every {period} number of episodes
         :param exp_source: experience source to use
         :param alpha: smoothing alpha param
         :param bound_avg_reward: optional boundary for average reward
-        :param subsample_end_of_episode: if given, end of episode event will be subsampled by this amount
+        :param period: if given, end of episode event fire once every {period} episodes
         """
         self._exp_source = exp_source
         self._alpha = alpha
         self._bound_avg_reward = bound_avg_reward
         self._best_avg_reward = None
-        self._subsample_end_of_episode = subsample_end_of_episode
+        self._period = period
 
     def attach(self, engine: Engine):
-        engine.add_event_handler(Events.ITERATION_COMPLETED, self)
-        engine.register_events(*EpisodeEvents)
+        engine.add_event_handler( Events.ITERATION_COMPLETED, self ) # invoke EndOfEpisodeHandler() instance whenever an iteration (consisting of multiple episodes) is completed
+        engine.register_events( *EpisodeEvents )
         State.event_to_attr[EpisodeEvents.EPISODE_COMPLETED] = "episode"
         State.event_to_attr[EpisodeEvents.BOUND_REWARD_REACHED] = "episode"
         State.event_to_attr[EpisodeEvents.BEST_REWARD_REACHED] = "episode"
 
     def __call__(self, engine: Engine):
+        # pop_rewards_steps() returns a list of (total rewards, steps) of newly completed episodes since the last call of pop_rewards_steps().
         for reward, steps in self._exp_source.pop_rewards_steps():
             engine.state.episode = getattr(engine.state, "episode", 0) + 1
-            engine.state.episode_reward = reward
+            engine.state.episode_reward = reward # sum of immediate rewards of all steps during the episode, without discounting
             engine.state.episode_steps = steps
             engine.state.metrics['reward'] = reward
             engine.state.metrics['steps'] = steps
             self._update_smoothed_metrics(engine, reward, steps)
-            if self._subsample_end_of_episode is None or engine.state.episode % self._subsample_end_of_episode == 0:
-                engine.fire_event(EpisodeEvents.EPISODE_COMPLETED)
+            if self._period is None or engine.state.episode % self._period == 0:
+                engine.fire_event( EpisodeEvents.EPISODE_COMPLETED )
             if self._bound_avg_reward is not None and engine.state.metrics['avg_reward'] >= self._bound_avg_reward:
                 engine.fire_event(EpisodeEvents.BOUND_REWARD_REACHED)
             if self._best_avg_reward is None:
@@ -110,13 +109,10 @@ class PeriodEvents(EventEnum):
     ITERS_10000_COMPLETED = "iterations_10000_completed"
     ITERS_100000_COMPLETED = "iterations_100000_completed"
 
-
 class PeriodicEvents:
     """
-    The same as CustomPeriodicEvent from ignite.contrib, but use true amount of iterations,
-    which is good for TensorBoard
+    The same as CustomPeriodicEvent from ignite.contrib, but use true amount of iterations, which is good for TensorBoard
     """
-
     INTERVAL_TO_EVENT = {
         10: PeriodEvents.ITERS_10_COMPLETED,
         100: PeriodEvents.ITERS_100_COMPLETED,

simonbb-0.0.8/src/simonbb/cis433/math500.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import re
+import time
+import json
+from pathlib import Path
+from ..utils import grade_math_answer, eta_progress_message
+
+RE_NUMBER = re.compile( r"-?(?:\d+/\d+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)" )
+def get_last_boxed(text):
+    # Find the last occurrence of "\boxed"
+    boxed_start_idx = text.rfind(r"\boxed")
+    if boxed_start_idx == -1:
+        return None
+    # Get position after "\boxed"
+    current_idx = boxed_start_idx + len(r"\boxed")
+    # Skip any whitespace after "\boxed"
+    while current_idx < len(text) and text[current_idx].isspace():
+        current_idx += 1
+    # Expect an opening brace "{"
+    if current_idx >= len(text) or text[current_idx] != "{":
+        return None
+    # Parse the braces with nesting
+    current_idx += 1
+    brace_depth = 1
+    content_start_idx = current_idx
+    while current_idx < len(text) and brace_depth > 0:
+        char = text[current_idx]
+        if char == "{":
+            brace_depth += 1
+        elif char == "}":
+            brace_depth -= 1
+        current_idx += 1
+    # Account for unbalanced braces
+    if brace_depth != 0:
+        return None
+    # Extract content inside the outermost braces
+    return text[content_start_idx:current_idx-1]
+
+def extract_final_candidate(text, fallback="number_then_full"):
+    # Default return value if nothing matches
+    result = ""
+    if text:        
+        boxed = get_last_boxed(text.strip()) # Prefer the last boxed expression if present
+        if boxed:
+            result = boxed.strip().strip("$ ")
+        # If no boxed expression, try fallback
+        elif fallback in ("number_then_full", "number_only"):
+            m = RE_NUMBER.findall(text)
+            if m: # Use last number
+                result = m[-1]
+            elif fallback == "number_then_full":
+                # Else return full text if no number found
+                result = text
+    return result
+
+def render_prompt(prompt):
+    template = (
+        "You are a helpful math assistant.\n"
+        "Answer the question and write the final result on a new line as:\n"
+        "\\boxed{ANSWER}\n\n"
+        f"Question:\n{prompt}\n\nAnswer:"
+    )
+    return template
+
+
+def evaluate_math500_stream( model, tokenizer, device, generate_func, math_data, out_path=None, max_new_tokens=512, verbose=False ):
+    num_examples = len(math_data)
+    num_correct = 0
+    start_time = time.time()
+    with open(Path( out_path ), "w", encoding="utf-8") as f:  # Save results for inspection
+        for i, row in enumerate(math_data, start=1):
+            prompt = render_prompt(row["problem"])    # 1. Apply prompt template
+            gen_text = generate_func( model=model, tokenizer=tokenizer, prompt=prompt, device=device, max_new_tokens=max_new_tokens, verbose=verbose )
+            extracted = extract_final_candidate( gen_text )
+            is_correct = grade_math_answer( extracted, row["answer"] )
+            num_correct += int(is_correct)
+            record = {  # Record to be saved for inspection
+                "index": i,
+                "problem": row["problem"],
+                "gtruth_answer": row["answer"],
+                "generated_text": gen_text,
+                "extracted": extracted,
+                "correct": bool(is_correct),
+            }
+            f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+            progress_msg = eta_progress_message( processed=i, total=num_examples, start_time=start_time, show_eta=True, label="MATH-500" )
+            print(progress_msg, end="\r", flush=True)
+            if verbose:  # Print responses during the generation process
+                print(
+                    f"\n\n{'='*50}\n{progress_msg}\n"
+                    f"{'='*50}\nExtracted: {extracted}\n"
+                    f"Expected:  {row['answer']}\n"
+                    f"Correct so far: {num_correct}\n{'-'*50}"
+                )
+
+    # Print summary information
+    seconds_elapsed = time.time() - start_time
+    acc = num_correct / num_examples if num_examples else 0.0
+    print(f"\nAccuracy: {acc*100:.1f}% ({num_correct}/{num_examples})")
+    print(f"Total time: {seconds_elapsed/60:.1f} min")
+    print(f"Logs written to: {out_path}")
+    return num_correct, num_examples, acc