Get Started with Reinforcement Learning: Your First Concrete Step Today

# Open PowerShell as administrator, then:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
# Answer Y (Yes) to the confirmation

python --version
# Python 3.x.x (the default version in PATH)

py -3.9 --version
# Python 3.9.x

py -3.10 --version
# Python 3.10.x

py -3.11 --version
# Python 3.11.x

py -3.12 --version
# Python 3.12.x

py -3.13 --version
# Python 3.13.x

# Check the version
py -3.9 --version

# Create the virtual environment
py -3.9 -m venv myenv39

# Activate the environment (PowerShell)
.\myenv39\Scripts\activate

# The prompt changes: (myenv39) indicates the env is active
(myenv39) python --version
# Python 3.9.x

(myenv39) pip install streamlit
(myenv39) pip show streamlit
# Name: streamlit
# Version: 1.x.x
# ...

# Deactivate the environment
(myenv39) deactivate

py -3.10 --version
py -3.10 -m venv myenv310

.\myenv310\Scripts\activate

(myenv310) python --version
# Python 3.10.x

(myenv310) pip install streamlit
(myenv310) pip show streamlit
(myenv310) deactivate

# Python 3.11
py -3.11 -m venv myenv311
.\myenv311\Scripts\activate
(myenv311) python --version
(myenv311) pip install streamlit
(myenv311) deactivate

# Python 3.12
py -3.12 -m venv myenv312
.\myenv312\Scripts\activate
(myenv312) python --version
(myenv312) pip install streamlit
(myenv312) deactivate

# Python 3.13
py -3.13 -m venv myenv313
.\myenv313\Scripts\activate
(myenv313) python --version
(myenv313) pip install streamlit
(myenv313) deactivate

su                         # or: sudo -s
apt install openssh-server -y
systemctl status ssh       # check status
systemctl start ssh        # start if needed
systemctl enable ssh       # start automatically at boot

# Find the VM's IP address
ip -br addr
# lo               UNKNOWN        127.0.0.1/8
# eth0             UP             192.168.2.139/24   ← copy this IP

import gymnasium as gym
import numpy as np

# Create the environment
env = gym.make("CartPole-v1")
obs, info = env.reset(seed=42)

print("=== CartPole-v1 ===")
print(f"State space  : {env.observation_space}")
print(f"  Number of dimensions : {env.observation_space.shape[0]}")
print(f"  Min values : {env.observation_space.low}")
print(f"  Max values : {env.observation_space.high}")
print(f"\nAction space : {env.action_space}")
print(f"  Number of actions : {env.action_space.n}")
print(f"  Actions : 0 (left), 1 (right)")
print(f"\nInitial observation : {obs}")
print(f"  [cart position, cart velocity, pole angle, pole velocity]")

env.close()

import gymnasium as gym
import numpy as np
import matplotlib.pyplot as plt

def run_random_agent(env_name, n_episodes=100):
    """Agent that takes random actions - our baseline."""
    env = gym.make(env_name)
    total_rewards = []

    for episode in range(n_episodes):
        obs, info = env.reset()
        episode_reward = 0
        done = False

        while not done:
            # Random action (no learning)
            action = env.action_space.sample()
            obs, reward, terminated, truncated, info = env.step(action)
            episode_reward += reward
            done = terminated or truncated

        total_rewards.append(episode_reward)

    env.close()
    return total_rewards

# Run the random agent
rewards = run_random_agent("CartPole-v1", n_episodes=100)

print(f"Average reward : {np.mean(rewards):.2f}")
print(f"Maximum reward : {np.max(rewards):.0f}")
print(f"Minimum reward : {np.min(rewards):.0f}")

# Visualize
plt.figure(figsize=(10, 4))
plt.plot(rewards, alpha=0.6, label="Reward per episode")
plt.axhline(np.mean(rewards), color='red', linestyle='--', label=f"Mean: {np.mean(rewards):.1f}")
plt.xlabel("Episode")
plt.ylabel("Total reward")
plt.title("Random agent - CartPole-v1")
plt.legend()
plt.tight_layout()
plt.savefig("random_agent_cartpole.png")
plt.show()

import gymnasium as gym

# FrozenLake : 4x4 grid with discrete states
env = gym.make("FrozenLake-v1", is_slippery=False)
obs, info = env.reset()

print("=== FrozenLake-v1 ===")
print(f"State space  : {env.observation_space.n} states (4x4 grid)")
print(f"Action space : {env.action_space.n} actions")
print(f"  0=left, 1=down, 2=right, 3=up")
print(f"\nInitial state : {obs}")
print("\nVisualize the grid :")
env.render()

# Manual loop
manual_actions = [2, 2, 1, 1, 1, 2, 1, 2, 2]  # path to the exit
total_reward = 0

print("\n--- Manual simulation ---")
obs, _ = env.reset()
for i, action in enumerate(manual_actions):
    obs, reward, terminated, truncated, _ = env.step(action)
    total_reward += reward
    direction = ["←", "↓", "→", "↑"][action]
    print(f"Step {i+1}: {direction}  State={obs}  Reward={reward}")
    if terminated or truncated:
        break

print(f"\nTotal reward : {total_reward}")
env.close()