simonbb 0.0.4__tar.gz → 0.0.5__tar.gz

{simonbb-0.0.4 → simonbb-0.0.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: simonbb
-Version: 0.0.4
-Summary: A small package to facilitate teaching AI courses
+Version: 0.0.5
+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>
 License-Expression: MIT
@@ -21,6 +21,7 @@ Requires-Dist: numpy~=2.4.0
 Requires-Dist: pytorch-ignite~=0.5.4
 Requires-Dist: pyyaml~=6.0.3
 Requires-Dist: sentence-transformers~=5.3.0
+Requires-Dist: stable-baselines3~=2.9.0
 Requires-Dist: torchvision~=0.24.1
 Requires-Dist: torch~=2.9.1
 Requires-Dist: transformers~=4.57.3

{simonbb-0.0.4 → simonbb-0.0.5}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simonbb"
-version = "0.0.4"
+version = "0.0.5"
 authors = [
 	{ name="Huaxia Rui", email="huaxia.rui@simon.rochester.edu" },
 ]
-description = "A small package to facilitate teaching AI courses"
+description = "A small package to facilitate teaching AI courses at business schools"
 readme = "README.md"
 requires-python = ">=3.9"
 classifiers = [
@@ -32,6 +32,7 @@ dependencies = [
 	"sentence-transformers~=5.3.0",
 	"gymnasium~=1.3.0",
 	"pytorch-ignite~=0.5.4",
+	"stable_baselines3~=2.9.0",
 	"pyyaml~=6.0.3"
 ]
 [project.urls]

simonbb-0.0.5/src/simonbb/cis433/wrappers.py

@@ -0,0 +1,100 @@
+import typing as tt
+import gymnasium as gym
+from gymnasium import spaces
+import collections
+import numpy as np
+from stable_baselines3.common import atari_wrappers
+
+class ImageToPyTorch(gym.ObservationWrapper):
+    def __init__(self, env):
+        super(ImageToPyTorch, self).__init__(env)
+        obs = self.observation_space
+        assert isinstance(obs, gym.spaces.Box)
+        assert len(obs.shape) == 3
+        new_shape = (obs.shape[-1], obs.shape[0], obs.shape[1])
+        self.observation_space = gym.spaces.Box(
+            low=obs.low.min(), high=obs.high.max(),
+            shape=new_shape, dtype=obs.dtype)
+
+    def observation(self, observation):
+        return np.moveaxis(observation, 2, 0)
+
+
+class FrameStack1D(gym.Wrapper):
+    """
+    Stacks observations into 1D array
+    """
+    def __init__(self, env, k):
+        assert isinstance(env, gym.Env)
+        assert isinstance(env.observation_space, gym.spaces.Box)
+        assert len(env.observation_space.shape) == 1
+        super(FrameStack1D, self).__init__(env)
+        self.k = k
+        self.frames = collections.deque(maxlen=k)
+        shp = env.observation_space.shape
+        self.observation_space = gym.spaces.Box(
+            low=np.min(env.observation_space.low),
+            high=np.max(env.observation_space.high),
+            shape=(env.observation_space.shape[0]*k,),
+            dtype=env.observation_space.dtype)
+
+    def reset(self):
+        ob, extra = self.env.reset()
+        for _ in range(self.k):
+            self.frames.append(ob)
+        return self._get_ob(), extra
+
+    def step(self, action):
+        ob, reward, done, trunc, info = self.env.step(action)
+        self.frames.append(ob)
+        return self._get_ob(), reward, done, trunc, info
+
+    def _get_ob(self):
+        assert len(self.frames) == self.k
+        return np.concatenate(self.frames)
+
+
+
+class BufferWrapper(gym.ObservationWrapper):
+    def __init__(self, env, n_steps):
+        super(BufferWrapper, self).__init__(env)
+        obs = env.observation_space
+        assert isinstance(obs, spaces.Box)
+        new_obs = gym.spaces.Box(
+            obs.low.repeat(n_steps, axis=0),
+            obs.high.repeat(n_steps, axis=0), dtype=obs.dtype)
+        self.observation_space = new_obs
+        self.buffer = collections.deque(maxlen=n_steps)
+
+    def reset(self, *, seed: tt.Optional[int] = None,
+              options: tt.Optional[dict[str, tt.Any]] = None):
+        for _ in range(self.buffer.maxlen-1):
+            self.buffer.append(self.env.observation_space.low)
+        obs, extra = self.env.reset()
+        return self.observation(obs), extra
+
+    def observation(self, observation: np.ndarray) -> np.ndarray:
+        self.buffer.append(observation)
+        return np.concatenate(self.buffer)
+
+
+def wrap_dqn(env: gym.Env, stack_frames: int = 4,
+             episodic_life: bool = True, clip_reward: bool = True,
+             noop_max: int = 0) -> gym.Env:
+    """
+    Apply a common set of wrappers for Atari games.
+    :param env: Environment to wrap
+    :param stack_frames: count of frames to stack, default=4
+    :param episodic_life: convert life to end of episode
+    :param clip_reward: reward clipping
+    :param noop_max: how many NOOP actions to execute
+    :return: wrapped environment
+    """
+    assert 'NoFrameskip' in env.spec.id
+    env = atari_wrappers.AtariWrapper(
+        env, clip_reward=clip_reward, noop_max=noop_max,
+        terminal_on_life_loss=episodic_life)
+    env = ImageToPyTorch(env)
+    env = BufferWrapper(env, stack_frames)
+    return env
+

{simonbb-0.0.4 → simonbb-0.0.5}/src/simonbb/utils.py

@@ -1,11 +1,32 @@
+import time
 import re
+import collections
+import sys
 import pickle
 import json
 from collections import Counter
 import urllib.request
 import numpy as np
+import torch
+import torch.nn as nn
 
+class WeightedMSELoss(nn.Module):
+    def __init__(self, size_average=True):
+        super(WeightedMSELoss, self).__init__()
+        self.size_average = size_average
 
+    def forward(self, input, target, weights=None):
+        if weights is None:
+            return nn.MSELoss(self.size_average)(input, target)
+
+        loss_rows = (input - target) ** 2
+        if len(loss_rows.size()) != 1:
+            loss_rows = torch.sum(loss_rows, dim=1)
+        res = (weights * loss_rows).sum()
+        if self.size_average:
+            res /= len(weights)
+        return res
+    
 class TextVectorizer:
     def __init__(self, max_tokens=20000, output_mode="int", output_sequence_length=None, ngrams=None, standardize=None):
         self.max_tokens = max_tokens
@@ -123,6 +144,97 @@ class TextVectorizer:
         return vectorizer
 
 
+
+class TBMeanTracker:
+    """
+    TensorBoard value tracker: allows to batch fixed amount of historical values and write their mean into TB
+
+    Designed and tested with pytorch-tensorboard in mind
+    """
+    def __init__(self, writer, batch_size):
+        """
+        :param writer: writer with close() and add_scalar() methods
+        :param batch_size: integer size of batch to track
+        """
+        assert isinstance(batch_size, int)
+        assert writer is not None
+        self.writer = writer
+        self.batch_size = batch_size
+
+    def __enter__(self):
+        self._batches = collections.defaultdict(list)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.writer.close()
+
+    @staticmethod
+    def _as_float(value):
+        assert isinstance(value, (float, int, np.ndarray, np.generic, torch.autograd.Variable)) or torch.is_tensor(value)
+        tensor_val = None
+        if isinstance(value, torch.autograd.Variable):
+            tensor_val = value.data
+        elif torch.is_tensor(value):
+            tensor_val = value
+
+        if tensor_val is not None:
+            return tensor_val.float().mean().item()
+        elif isinstance(value, np.ndarray):
+            return float(np.mean(value))
+        else:
+            return float(value)
+
+    def track(self, param_name, value, iter_index):
+        assert isinstance(param_name, str)
+        assert isinstance(iter_index, int)
+
+        data = self._batches[param_name]
+        data.append(self._as_float(value))
+
+        if len(data) >= self.batch_size:
+            self.writer.add_scalar(param_name, np.mean(data), iter_index)
+            data.clear()
+
+
+class RewardTracker:
+    def __init__(self, writer, min_ts_diff=1.0):
+        """
+        Constructs RewardTracker
+        :param writer: writer to use for writing stats
+        :param min_ts_diff: minimal time difference to track speed
+        """
+        self.writer = writer
+        self.min_ts_diff = min_ts_diff
+
+    def __enter__(self):
+        self.ts = time.time()
+        self.ts_frame = 0
+        self.total_rewards = []
+        return self
+
+    def __exit__(self, *args):
+        self.writer.close()
+
+    def reward(self, reward, frame, epsilon=None):
+        self.total_rewards.append(reward)
+        mean_reward = np.mean(self.total_rewards[-100:])
+        ts_diff = time.time() - self.ts
+        if ts_diff > self.min_ts_diff:
+            speed = (frame - self.ts_frame) / ts_diff
+            self.ts_frame = frame
+            self.ts = time.time()
+            epsilon_str = "" if epsilon is None else ", eps %.2f" % epsilon
+            print("%d: done %d episodes, mean reward %.3f, speed %.2f f/s%s" % (
+                frame, len(self.total_rewards), mean_reward, speed, epsilon_str
+            ))
+            sys.stdout.flush()
+            self.writer.add_scalar("speed", speed, frame)
+        if epsilon is not None:
+            self.writer.add_scalar("epsilon", epsilon, frame)
+        self.writer.add_scalar("reward_100", mean_reward, frame)
+        self.writer.add_scalar("reward", reward, frame)
+        return mean_reward if len(self.total_rewards) > 30 else None
+    
 def query_ollama(prompt, model="llama3", url="http://localhost:11434/api/chat"):
     # Create the data payload as a dictionary
     data = {