Lance-toi en Débuter Reinforcement Learning : ton premier pas concret aujourd'hui

# Ouvrir PowerShell en administrateur, puis :
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
# Répondre O (Oui) à la confirmation

python --version
# Python 3.x.x (la version par défaut dans le 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

# Vérifier la version
py -3.9 --version

# Créer l'environnement virtuel
py -3.9 -m venv myenv39

# Activer l'environnement (PowerShell)
.\myenv39\Scripts\activate

# Le prompt change : (myenv39) indique que l'env est actif
(myenv39) python --version
# Python 3.9.x

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

# Désactiver l'environnement
(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                         # ou : sudo -s
apt install openssh-server -y
systemctl status ssh       # vérifier le statut
systemctl start ssh        # démarrer si nécessaire
systemctl enable ssh       # démarrer automatiquement au boot

# Trouver l'adresse IP de la VM
ip -br addr
# lo               UNKNOWN        127.0.0.1/8
# eth0             UP             192.168.2.139/24   ← copier cette IP

import gymnasium as gym
import numpy as np

# Créer l'environnement
env = gym.make("CartPole-v1")
obs, info = env.reset(seed=42)

print("=== CartPole-v1 ===")
print(f"Espace d'états  : {env.observation_space}")
print(f"  Nombre de dimensions : {env.observation_space.shape[0]}")
print(f"  Valeurs min : {env.observation_space.low}")
print(f"  Valeurs max : {env.observation_space.high}")
print(f"\nEspace d'actions : {env.action_space}")
print(f"  Nombre d'actions : {env.action_space.n}")
print(f"  Actions : 0 (gauche), 1 (droite)")
print(f"\nObservation initiale : {obs}")
print(f"  [position cart, vitesse cart, angle bâton, vitesse bâton]")

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 qui prend des actions aléatoires - notre 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:
            # Action aléatoire (pas d'apprentissage)
            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

# Exécuter l'agent aléatoire
rewards = run_random_agent("CartPole-v1", n_episodes=100)

print(f"Récompense moyenne : {np.mean(rewards):.2f}")
print(f"Récompense maximale : {np.max(rewards):.0f}")
print(f"Récompense minimale : {np.min(rewards):.0f}")

# Visualiser
plt.figure(figsize=(10, 4))
plt.plot(rewards, alpha=0.6, label="Récompense par épisode")
plt.axhline(np.mean(rewards), color='red', linestyle='--', label=f"Moyenne: {np.mean(rewards):.1f}")
plt.xlabel("Épisode")
plt.ylabel("Récompense totale")
plt.title("Agent aléatoire - CartPole-v1")
plt.legend()
plt.tight_layout()
plt.savefig("agent_aleatoire_cartpole.png")
plt.show()

import gymnasium as gym

# FrozenLake : grille 4x4 avec états discrets
env = gym.make("FrozenLake-v1", is_slippery=False)
obs, info = env.reset()

print("=== FrozenLake-v1 ===")
print(f"Espace d'états  : {env.observation_space.n} états (grille 4x4)")
print(f"Espace d'actions : {env.action_space.n} actions")
print(f"  0=gauche, 1=bas, 2=droite, 3=haut")
print(f"\nÉtat initial : {obs}")
print("\nVisualisez la grille :")
env.render()

# Boucle manuelle
actions_manuelles = [2, 2, 1, 1, 1, 2, 1, 2, 2]  # chemin vers la sortie
total_reward = 0

print("\n--- Simulation manuelle ---")
obs, _ = env.reset()
for i, action in enumerate(actions_manuelles):
    obs, reward, terminated, truncated, _ = env.step(action)
    total_reward += reward
    direction = ["←", "↓", "→", "↑"][action]
    print(f"Étape {i+1}: {direction}  État={obs}  Récompense={reward}")
    if terminated or truncated:
        break

print(f"\nRécompense totale : {total_reward}")
env.close()