lab-copy 0.1.0__py3-none-any.whl

lab_copy/__init__.py

@@ -0,0 +1,459 @@
+codes = {
+    1: """import numpy as np
+import matplotlib.pyplot as plt
+
+# Gridworld Environment Setup
+GRID_SIZE = 5
+ACTIONS = ['up', 'down', 'left', 'right']
+ACTION_DICT = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'right': (0, 1)}
+GOAL_STATE = (4, 4)
+MAX_STEPS = 50
+
+def is_valid_state(state):
+    return 0 <= state[0] < GRID_SIZE and 0 <= state[1] < GRID_SIZE
+
+def step(state, action):
+    move = ACTION_DICT[action]
+    new_state = (state[0] + move[0], state[1] + move[1])
+    if not is_valid_state(new_state):
+        new_state = state # stay if move goes out of bounds
+    reward = 10 if new_state == GOAL_STATE else 0
+    done = (new_state == GOAL_STATE)
+    return new_state, reward, done
+
+# Agent Loop
+def run_episode():
+    state = (0, 0)
+    total_reward = 0
+    trajectory = [state]
+    for step_num in range(MAX_STEPS):
+        action = np.random.choice(ACTIONS) # Random policy
+        next_state, reward, done = step(state, action)
+        trajectory.append(next_state)
+        total_reward += reward
+        state = next_state
+        if done:
+            break
+    return trajectory, total_reward
+
+# Run 10 episodes and visualize one
+for ep in range(10):
+    traj, reward = run_episode()
+    print(f"Episode {ep+1}: Total Reward = {reward}, Steps = {len(traj)}")
+
+# Visualize trajectory of the last episode
+def plot_trajectory(trajectory):
+    grid = np.zeros((GRID_SIZE, GRID_SIZE))
+    for (x, y) in trajectory:
+        grid[x, y] += 1
+    plt.imshow(grid, cmap='Blues', origin='upper')
+    plt.title("Agent Trajectory Heatmap")
+    plt.colorbar(label="Visits")
+    plt.scatter(0, 0, c='green', s=100, label='Start')
+    plt.scatter(4, 4, c='red', s=100, label='Goal')
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+plot_trajectory(traj)""",
+    2: """import numpy as np
+import matplotlib.pyplot as plt
+
+class EpsilonGreedyAgent:
+    def __init__(self, n_arms, epsilon):
+        self.n_arms = n_arms
+        self.epsilon = epsilon
+        self.counts = np.zeros(n_arms) # Number of times each arm was pulled
+        self.values = np.zeros(n_arms) # Estimated value (CTR) for each arm
+        self.total_reward = 0
+        self.actions = []
+        self.rewards = []
+
+    def select_action(self):
+        if np.random.rand() < self.epsilon:
+            return np.random.randint(self.n_arms) # Explore
+        else:
+            return np.argmax(self.values) # Exploit
+
+    def update(self, action, reward):
+        self.counts[action] += 1
+        self.values[action] += (reward - self.values[action]) / self.counts[action]
+        self.total_reward += reward
+        self.actions.append(action)
+        self.rewards.append(reward)
+
+def simulate_bandit(true_ctrs, epsilon, n_rounds=1000):
+    n_arms = len(true_ctrs)
+    agent = EpsilonGreedyAgent(n_arms, epsilon)
+    optimal_arm = np.argmax(true_ctrs)
+    regrets = []
+    for t in range(n_rounds):
+        action = agent.select_action()
+        reward = np.random.rand() < true_ctrs[action]
+        agent.update(action, reward)
+        regret = true_ctrs[optimal_arm] - true_ctrs[action]
+        regrets.append(regret)
+    return agent, np.cumsum(regrets)
+
+# ---------- Main Experiment ----------
+np.random.seed(42)
+n_arms = 10
+true_ctrs = np.random.uniform(0.05, 0.5, n_arms)
+print("True Click-Through Rates (CTR) per Ad:", np.round(true_ctrs, 2))
+n_rounds = 1000
+epsilons = [0.01, 0.1, 0.3]
+agents = {}
+regret_curves = {}
+for epsilon in epsilons:
+    agent, regrets = simulate_bandit(true_ctrs, epsilon, n_rounds)
+    agents[epsilon] = agent
+    regret_curves[epsilon] = regrets
+
+# ---------- Plotting Results ----------
+plt.figure(figsize=(12, 5))
+# Plot cumulative regret
+plt.subplot(1, 2, 1)
+for epsilon in epsilons:
+    plt.plot(regret_curves[epsilon], label=f'ε={epsilon}')
+plt.title("Cumulative Regret")
+plt.xlabel("Rounds")
+plt.ylabel("Cumulative Regret")
+plt.legend()
+plt.grid(True) 
+
+plt.subplot(1, 2, 2)
+bar_width = 0.25
+x = np.arange(n_arms)
+for i, epsilon in enumerate(epsilons):
+    plt.bar(x + i * bar_width,
+            agents[epsilon].values,
+            width=bar_width,
+            label=f'ε={epsilon}')
+plt.axhline(np.max(true_ctrs), color='r', linestyle='--', label='Optimal CTR')
+plt.xticks(x + bar_width, [f'Ad {i}' for i in range(n_arms)])
+plt.ylabel("Estimated CTR")
+plt.title("Estimated CTRs vs True CTR")
+plt.legend()
+plt.grid(True)
+plt.tight_layout()
+plt.show()""",
+    3: """import numpy as np
+import mdptoolbox
+import matplotlib.pyplot as plt
+import random
+
+# Grid Parameters
+rows, cols = 5, 5
+num_states = rows * cols
+shelves = [(1, 1), (2, 2), (3, 3)] # Obstacle positions
+actions = ['up', 'down', 'left', 'right']
+num_actions = len(actions)
+movement = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'right': (0, 1)}
+
+# Function to map (x, y) to index
+def to_index(x, y):
+    return x * cols + y
+
+# Function to randomly set a goal not on a shelf
+def set_dynamic_goal():
+    possible = [(i, j) for i in range(rows) for j in range(cols) if (i, j) not in shelves]
+    return random.choice(possible)
+
+# Randomly choose a goal position
+goal_state = set_dynamic_goal()
+print("  Current Goal Position:", goal_state)
+
+# Transition and Reward Matrices
+P = [np.zeros((num_states, num_states)) for _ in range(num_actions)]
+R = np.zeros((num_states, num_actions)) 
+
+for action_idx, action in enumerate(actions):
+    dx, dy = movement[action]
+    for x in range(rows):
+        for y in range(cols):
+            current_state = to_index(x, y)
+            if (x, y) == goal_state:
+                P[action_idx][current_state, current_state] = 1
+                R[current_state, action_idx] = 10
+                continue
+            
+            outcomes = []
+            # Intended move (90%)
+            new_x, new_y = x + dx, y + dy
+            if (new_x, new_y) in shelves or not (0 <= new_x < rows and 0 <= new_y < cols):
+                new_state = current_state
+                reward = -5 if (new_x, new_y) in shelves else -1
+            else:
+                new_state = to_index(new_x, new_y)
+                reward = -1
+            outcomes.append((new_state, 0.9, reward))
+            
+            # 10% misstep (wrong move in any of the other 3 directions)
+            other_actions = [a for i, a in enumerate(actions) if i != action_idx]
+            for mis_action in other_actions:
+                mx, my = movement[mis_action]
+                new_x, new_y = x + mx, y + my
+                if (new_x, new_y) in shelves or not (0 <= new_x < rows and 0 <= new_y < cols):
+                    mis_state = current_state
+                    mis_reward = -5 if (new_x, new_y) in shelves else -1
+                else:
+                    mis_state = to_index(new_x, new_y)
+                    mis_reward = -1
+                outcomes.append((mis_state, 0.1 / 3, mis_reward))
+            
+            for s_next, prob, rew in outcomes:
+                P[action_idx][current_state, s_next] += prob
+                R[current_state, action_idx] += prob * rew # Expected reward
+
+# Run Value Iteration
+vi = mdptoolbox.mdp.ValueIteration(P, R, 0.9)
+vi.run()
+
+# Reshape policy to grid
+policy_grid = np.array(vi.policy).reshape((rows, cols))
+action_symbols = ['↑', '↓', '←', '→']
+policy_symbols = np.array([[action_symbols[a] for a in row] for row in policy_grid])
+print("\\n📍 Optimal Policy Grid:")
+print(policy_symbols)
+
+# Plotting
+plt.figure(figsize=(6, 6))
+for x in range(rows):
+    for y in range(cols):
+        idx = to_index(x, y)
+        if (x, y) == goal_state:
+            plt.text(y, rows - x - 1, 'G', ha='center', va='center', fontsize=14, color='green')
+        elif (x, y) in shelves:
+            plt.text(y, rows - x - 1, 'S', ha='center', va='center', fontsize=14, color='red')
+        else:
+            plt.text(y, rows - x - 1, action_symbols[vi.policy[idx]], ha='center', va='center', fontsize=14)
+plt.xticks(range(cols))
+plt.yticks(range(rows))
+plt.grid(True)
+plt.title("Stochastic Optimal Policy with Dynamic Goal")
+plt.show()""",
+    4: """import numpy as np
+import matplotlib.pyplot as plt
+from collections import defaultdict
+import random
+
+# ---------- Environment Setup ----------
+GRID_SIZE = 6
+ACTIONS = ['up', 'down', 'left', 'right']
+ACTION_MAP = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'right': (0, 1)}
+MAX_STEPS = 50
+DISCOUNT = 0.95
+EPSILON = 0.1
+EPISODES = 10000
+
+# Static obstacles (permanent roadblocks)
+static_obstacles = [(1, 3), (3, 2)]
+hospital = (0, 0) # Ambulance dispatch center
+
+# Rush hour control
+def is_rush_hour(ep):
+    return ep % 1000 < 300 or ep % 1000 > 800 # Congested traffic windows
+
+# Emergency severity and urgency
+emergency_types = {
+    'minor': 20,
+    'moderate': 35,
+    'critical': 50
+}
+
+def is_valid(state):
+    x, y = state
+    return 0 <= x < GRID_SIZE and 0 <= y < GRID_SIZE
+
+def get_dynamic_obstacles():
+    return [(2, 4), (4, 1), (3, 3)] if random.random() < 0.3 else []
+
+def epsilon_greedy(state, Q):
+    if np.random.rand() < EPSILON or state not in Q:
+        return random.randint(0, len(ACTIONS) - 1)
+    else:
+        return np.argmax(Q[state])
+
+def generate_emergency():
+    location = random.choice([
+        (i, j) for i in range(GRID_SIZE) for j in range(GRID_SIZE)
+        if (i, j) != hospital and (i, j) not in static_obstacles
+    ])
+    severity = random.choice(list(emergency_types.keys()))
+    reward = emergency_types[severity]
+    return location, reward
+
+# ---------- Monte Carlo Training ----------
+Q = defaultdict(lambda: np.zeros(len(ACTIONS)))
+Returns = defaultdict(list)
+
+def run_episode(episode_num):
+    rush = is_rush_hour(episode_num)
+    prob_blocks = get_dynamic_obstacles()
+    all_obstacles = static_obstacles + prob_blocks
+    goal, goal_reward = generate_emergency()
+    state = hospital
+    episode = []
+    steps = 0
+    while steps < MAX_STEPS:
+        action_idx = epsilon_greedy(state, Q)
+        dx, dy = ACTION_MAP[ACTIONS[action_idx]]
+        next_state = (state[0] + dx, state[1] + dy)
+        
+        if not is_valid(next_state) or next_state in all_obstacles:
+            reward = -10 if rush else -5
+            next_state = state
+        elif next_state == goal:
+            reward = goal_reward - steps
+        else:
+            reward = -2 if rush else -1
+            
+        episode.append((state, action_idx, reward))
+        if next_state == goal:
+            break
+        state = next_state
+        steps += 1
+    return episode
+
+for ep in range(EPISODES):
+    episode = run_episode(ep)
+    G = 0
+    visited = set()
+    for t in reversed(range(len(episode))):
+        s, a, r = episode[t]
+        G = DISCOUNT * G + r
+        if (s, a) not in visited:
+            Returns[(s, a)].append(G)
+            Q[s][a] = np.mean(Returns[(s, a)])
+            visited.add((s, a)) # ✅ FIXED: used tuple, not list
+print("🚑 Training Complete: Smart Ambulance Dispatch Policy Learned.")
+
+# ---------- Policy Visualization ----------
+policy = np.full((GRID_SIZE, GRID_SIZE), '.', dtype=str)
+for i in range(GRID_SIZE):
+    for j in range(GRID_SIZE):
+        state = (i, j)
+        if state in static_obstacles:
+            policy[i][j] = 'S'
+        elif state in Q:
+            best_action = np.argmax(Q[state])
+            policy[i][j] = ['↑', '↓', '←', '→'][best_action]
+        else:
+            policy[i][j] = ' '
+            
+print("\\n📍 Learned Ambulance Dispatch Policy Grid:")
+for row in policy:
+    print(' '.join(row))""",
+    5: """import numpy as np
+import random
+import matplotlib.pyplot as plt
+
+# Configuration
+FLOORS = 5
+ACTIONS = ['stay', 'up', 'down']
+ACTION_SPACE = {0: 'stay', 1: 'up', 2: 'down'}
+N_ACTIONS = len(ACTIONS)
+GAMMA = 0.9 # Discount factor
+ALPHA = 0.1 # Learning rate
+EPSILON = 0.1 # Exploration rate
+EPISODES = 10000
+MAX_STEPS = 50
+USE_SARSA = False # 🔁 Set to True to use SARSA; False for Q-Learning
+
+# Initialize Q-table: Q[state][action]
+Q = np.zeros((FLOORS, FLOORS, N_ACTIONS)) # [elevator_floor][request_floor][action]
+episode_rewards = []
+
+# Helper functions
+def select_action(state):
+    ef, rf = state
+    if random.random() < EPSILON:
+        return random.randint(0, N_ACTIONS - 1)
+    return np.argmax(Q[ef][rf])
+
+def take_action(ef, action):
+    if action == 0: # stay
+        return ef
+    elif action == 1: # up
+        return min(ef + 1, FLOORS - 1)
+    elif action == 2: # down
+        return max(ef - 1, 0)
+
+def get_reward(ef, rf, next_ef):
+    if ef == rf and next_ef == rf:
+        return 10
+    elif abs(next_ef - rf) < abs(ef - rf):
+        return 1
+    elif abs(next_ef - rf) > abs(ef - rf):
+        return -2
+    elif next_ef == ef:
+        return -1
+    return -5
+
+# Training loop
+for ep in range(EPISODES):
+    ef = random.randint(0, FLOORS - 1) # elevator floor
+    rf = random.randint(0, FLOORS - 1) # request floor
+    state = (ef, rf)
+    total_reward = 0
+    action = select_action(state)
+    
+    for step in range(MAX_STEPS):
+        next_ef = take_action(ef, action)
+        reward = get_reward(ef, rf, next_ef)
+        total_reward += reward
+        next_state = (next_ef, rf)
+        next_action = select_action(next_state)
+        
+        if USE_SARSA:
+            Q[ef][rf][action] += ALPHA * (reward + GAMMA * Q[next_ef][rf][next_action] - Q[ef][rf][action])
+        else: # Q-Learning
+            Q[ef][rf][action] += ALPHA * (reward + GAMMA * np.max(Q[next_ef][rf]) - Q[ef][rf][action])
+            
+        ef = next_ef
+        rf = rf # request remains until served
+        state = next_state
+        action = next_action if USE_SARSA else select_action(state)
+        
+        if ef == rf:
+            break # request served
+            
+    episode_rewards.append(total_reward)
+    
+print(f"🏢 Training complete using {'SARSA' if USE_SARSA else 'Q-Learning'}.") 
+print("\\n📍 Learned Elevator Policy:")
+for ef in range(FLOORS):
+    for rf in range(FLOORS):
+        best_action = np.argmax(Q[ef][rf])
+        print(f"Elevator at {ef}, Request at {rf} → Action: {ACTION_SPACE[best_action]}")
+
+# Plot learning curve
+plt.plot(episode_rewards)
+plt.title(f"Episode Rewards ({'SARSA' if USE_SARSA else 'Q-Learning'})")
+plt.xlabel("Episode")
+plt.ylabel("Total Reward")
+plt.grid()
+plt.show()""",
+}
+
+descriptions = {
+    1: "core structure of Reinforcement Learning by simulating an agent-environment interaction loop in a simple Gridworld",
+    2: "ε-Greedy strategy for solving the multi-armed bandit problem click-through rate (CTR)",
+    3: "Markov Decision Process (MDP) and solve it using Value Iteration",
+    4: "Monte Carlo Control for Emergency Ambulance Dispatch in Smart Cities",
+    5: "Q-Learning for Intelligent Elevator Control in a Smart Building",
+}
+
+def info():
+    """Returns what the 5 codes are for."""
+    info_str = "This package contains 5 codes for the following:\\n"
+    for k, v in descriptions.items():
+        info_str += f"{k}. {v}\\n"
+    return info_str
+
+def question(n):
+    """Returns the code for the given question number."""
+    if n in codes:
+        return codes[n]
+    else:
+        return "Invalid question number. Please choose between 1 and 5."

lab_copy-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: lab_copy
+Version: 0.1.0
+Summary: A package containing 5 specific codes.
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: requires-python
+Dynamic: summary

lab_copy-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+lab_copy/__init__.py,sha256=njwz-l6qoxdY-SB13mTF-H_5Ty4E0Z_gDN2W-kXaAOc,15013
+lab_copy-0.1.0.dist-info/METADATA,sha256=pN1EFBNbYpJutNPgwK-tEH4WZUmyUncKfM4s6FjmSFk,439
+lab_copy-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+lab_copy-0.1.0.dist-info/top_level.txt,sha256=DbsIFHxtoewjU2SlS4x128s4_37Ou1PeQGXsB9GCXoU,9
+lab_copy-0.1.0.dist-info/RECORD,,

lab_copy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lab_copy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lab_copy