pixelcopter_train.py

"""
Self-contained Pixelcopter REINFORCE trainer for Colab.
Reads HF_TOKEN from env, trains, evaluates, early-stops when it clears the
certification threshold (mean_reward - std >= 5), and pushes to the Hub.
Uses the OLD gym API (gym_pygame / PLE). Run headless via SDL dummy driver.
"""
import os
os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
os.environ.setdefault("SDL_AUDIODRIVER", "dummy")

import json
import copy
from collections import deque

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Categorical
import imageio
import gym
import gym_pygame  # noqa: F401  registers Pixelcopter-PLE-v0

from huggingface_hub import HfApi, login, metadata_eval_result, metadata_save

TOKEN = os.environ["HF_TOKEN"]
USER = "SamTru88"
ENV_ID = "Pixelcopter-PLE-v0"
REPO = f"{USER}/Reinforce-{ENV_ID}"
THRESHOLD = 5.0
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


class Policy(nn.Module):
    def __init__(self, s, a, h=64):
        super().__init__()
        self.fc1 = nn.Linear(s, h)
        self.fc2 = nn.Linear(h, h * 2)
        self.fc3 = nn.Linear(h * 2, a)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return torch.softmax(self.fc3(x), dim=1)

    def act(self, state):
        state = torch.from_numpy(np.array(state)).float().unsqueeze(0).to(device)
        probs = self.forward(state)
        m = Categorical(probs)
        action = m.sample()
        return action.item(), m.log_prob(action)


def make_env():
    return gym.make(ENV_ID)


def evaluate(policy, n_eval, max_t):
    env = make_env()
    rewards = []
    for _ in range(n_eval):
        state = env.reset()
        total = 0.0
        for _ in range(max_t):
            a, _ = policy.act(state)
            state, r, done, _ = env.step(a)
            total += r
            if done:
                break
        rewards.append(total)
    return float(np.mean(rewards)), float(np.std(rewards))


def train():
    env = make_env()
    s_size = env.observation_space.shape[0]
    a_size = env.action_space.n
    policy = Policy(s_size, a_size, 64).to(device)
    opt = optim.Adam(policy.parameters(), lr=1e-4)
    gamma, max_t = 0.99, 10000
    scores = deque(maxlen=100)
    best_score, best_state = -1e9, copy.deepcopy(policy.state_dict())
    for ep in range(1, 60001):
        log_probs, rewards = [], []
        state = env.reset()
        for _ in range(max_t):
            a, lp = policy.act(state)
            log_probs.append(lp)
            state, r, done, _ = env.step(a)
            rewards.append(r)
            if done:
                break
        scores.append(sum(rewards))
        returns = deque()
        R = 0.0
        for r in reversed(rewards):
            R = r + gamma * R
            returns.appendleft(R)
        returns = torch.tensor(returns)
        returns = (returns - returns.mean()) / (returns.std() + 1e-9)
        loss = torch.cat([(-lp * R).reshape(1) for lp, R in zip(log_probs, returns)]).sum()
        opt.zero_grad(); loss.backward(); opt.step()
        # periodic eval + early stop with best checkpoint
        if ep % 1000 == 0:
            m, sd = evaluate(policy, 10, max_t)
            score = m - sd
            print(f"ep {ep}\tavg100 {np.mean(scores):.2f}\teval score {score:.2f}", flush=True)
            if score > best_score:
                best_score = score
                best_state = copy.deepcopy(policy.state_dict())
            if best_score >= THRESHOLD + 1:  # small margin
                break
    policy.load_state_dict(best_state)
    return policy, s_size, a_size


def push(policy, s_size, a_size, mean_r, std_r):
    login(token=TOKEN, add_to_git_credential=False)
    api = HfApi(token=TOKEN)
    api.create_repo(REPO, exist_ok=True, repo_type="model")
    os.makedirs("out", exist_ok=True)
    torch.save(policy.state_dict(), "out/model.pt")
    hp = dict(env_id=ENV_ID, h_size=64, n_training_episodes=60000,
              n_evaluation_episodes=10, max_t=10000, gamma=0.99, lr=1e-4,
              state_space=int(s_size), action_space=int(a_size))
    json.dump(hp, open("out/hyperparameters.json", "w"), indent=2)
    # replay video
    env = make_env()
    imgs = []
    state = env.reset()
    for _ in range(2000):
        a, _ = policy.act(state)
        state, _, done, _ = env.step(a)
        try:
            imgs.append(np.array(env.render(mode="rgb_array")))
        except Exception:
            pass
        if done:
            break
    if imgs:
        imageio.mimsave("out/replay.mp4", imgs, fps=30)
    meta = {"tags": [ENV_ID, "reinforce", "reinforcement-learning",
                     "custom-implementation", "deep-reinforcement-learning"]}
    eval_meta = metadata_eval_result(
        model_pretty_name=f"Reinforce-{ENV_ID}", task_pretty_name="reinforcement-learning",
        task_id="reinforcement-learning", metrics_pretty_name="mean_reward",
        metrics_id="mean_reward", metrics_value=f"{mean_r:.2f} +/- {std_r:.2f}",
        dataset_pretty_name=ENV_ID, dataset_id=ENV_ID)
    meta = {**meta, **eval_meta}
    with open("out/README.md", "w", encoding="utf-8") as f:
        f.write(f"# REINFORCE agent for {ENV_ID}\n\nMean reward: {mean_r:.2f} +/- {std_r:.2f}\n")
    metadata_save("out/README.md", meta)
    api.upload_folder(repo_id=REPO, folder_path="out", path_in_repo=".",
                      commit_message="REINFORCE Pixelcopter (Deep RL Unit 4)")
    print(f"PUSHED https://huggingface.co/{REPO}", flush=True)


if __name__ == "__main__":
    policy, s_size, a_size = train()
    m, sd = evaluate(policy, 10, 10000)
    print(f"FINAL mean={m:.2f} std={sd:.2f} score={m-sd:.2f} threshold={THRESHOLD} "
          f"{'PASS' if m-sd >= THRESHOLD else 'FAIL'}", flush=True)
    if m - sd >= THRESHOLD:
        push(policy, s_size, a_size, m, sd)
    else:
        print("Did not reach threshold; not pushing.", flush=True)