Upload human-like robot nav model

README.md

@@ -0,0 +1,154 @@
+---
+tags:
+- robotics
+- trajectory-generation
+- diffusion-model
+- navigation
+- human-like-motion
+- ddpm
+library_name: pytorch
+pipeline_tag: reinforcement-learning
+license: mit
+---
+
+# 🤖🚶 Human-Like Robot Navigation Trajectory Generator
+
+A **DDPM (Denoising Diffusion Probabilistic Model)** that generates human-like 2D navigation trajectories for robots.
+
+## What It Does
+
+Given a robot's current state (position + velocity) and a goal, this model generates future waypoints that mimic human walking — smooth curves, natural speed changes, and obstacle-aware paths.
+
+```
+Input:  [x, y, vx, vy] + [goal_x, goal_y]
+  ↓ DDPM Reverse Diffusion (100 steps)
+  ↓ 1D Temporal UNet + FiLM conditioning
+Output: 16 future waypoints [dx, dy]
+```
+
+## Key Features
+
+- 🚶 **Human-like paths** — smooth curves, not robotic straight lines
+- ⚡ **Variable speed** — acceleration, cruising, deceleration like real walking
+- 🧱 **Obstacle aware** — learned from social force model training data
+- 🎲 **Multi-modal** — generates diverse trajectory samples via diffusion
+- 🎯 **Goal-directed** — conditions on target position
+
+## Architecture
+
+| Component | Details |
+|-----------|---------|
+| Backbone | 1D Temporal UNet ([64, 128, 256]) |
+| Conditioning | FiLM (Feature-wise Linear Modulation) |
+| Noise Schedule | Cosine (Improved DDPM) |
+| Diffusion Steps | 100 |
+| Parameters | 1,801,538 (1.8M) |
+| Prediction | ε-prediction (noise) |
+
+## Based On
+
+- [Diffusion Policy](https://arxiv.org/abs/2303.04137) (Chi et al., RSS 2023)
+- [TRACE](https://arxiv.org/abs/2304.01893) (Rempe et al., CVPR 2023)
+- [Improved DDPM](https://arxiv.org/abs/2102.09672) (Nichol & Dhariwal, 2021)
+
+## Training Data
+
+2,000 synthetic episodes in a 20m × 20m environment with 8 obstacles:
+- Social Force Model physics (Helbing & Molnar 1995)
+- ~156K frames at 10 Hz
+- Speed range: 0.3-2.0 m/s (avg ~1.3 m/s, matching human walking)
+
+## Quick Start
+
+```python
+import torch, json, numpy as np
+
+# Load
+config = json.load(open('config.json'))
+stats = json.load(open('normalization_stats.json'))
+
+# Build model (copy architecture classes from this repo)
+model = HumanTrajDiffusion(ad=2, sd=4, gd=2, H=16, T=100, dims=tuple(config['down_dims']))
+model.load_state_dict(torch.load('model.pt', map_location='cpu'))
+model.eval()
+
+# Robot at (5,5) moving NE → goal (15,15)
+state = np.array([5.0, 5.0, 0.5, 0.3])
+goal = np.array([15.0, 15.0])
+
+state_n = torch.tensor((state - stats['state_mean']) / stats['state_std'], dtype=torch.float32)
+goal_n = torch.tensor((goal - stats['goal_mean']) / stats['goal_std'], dtype=torch.float32)
+
+# Generate 5 diverse paths
+trajectories = model.generate(state_n, goal_n, n=5)
+
+# → Real coordinates
+traj = trajectories.numpy() * stats['action_std'] + stats['action_mean']
+positions = np.cumsum(traj, axis=1) + state[:2]
+# positions.shape = (5, 16, 2) — 5 paths, 16 waypoints, (x,y)
+```
+
+## Config
+```json
+{
+  "horizon": 16,
+  "action_dim": 2,
+  "state_dim": 4,
+  "goal_dim": 2,
+  "num_diffusion_steps": 100,
+  "down_dims": [
+    64,
+    128,
+    256
+  ],
+  "batch_size": 32,
+  "total_steps": 8000,
+  "lr": 0.0002,
+  "weight_decay": 1e-05,
+  "warmup_steps": 200,
+  "grad_clip": 10.0,
+  "eval_freq": 2000,
+  "log_freq": 25,
+  "hub_model_id": "precison9/human-like-robot-nav-diffusion"
+}
+```
+
+## Normalization Stats
+```json
+{
+  "state_mean": [
+    9.887735366821289,
+    10.40771484375,
+    0.02240574173629284,
+    -0.010746479965746403
+  ],
+  "state_std": [
+    4.021646976470947,
+    3.9589571952819824,
+    0.7364981174468994,
+    0.7464056015014648
+  ],
+  "action_mean": [
+    0.0022544937673956156,
+    -0.001080495654605329
+  ],
+  "action_std": [
+    0.07394769042730331,
+    0.07494954019784927
+  ],
+  "goal_mean": [
+    10.106578826904297,
+    10.3273344039917
+  ],
+  "goal_std": [
+    4.950056076049805,
+    5.060120582580566
+  ]
+}
+```
+
+## Applications
+- 🤖 Mobile robot navigation
+- 🎮 NPC pedestrian AI
+- 🏗️ Crowd simulation
+- 📊 Trajectory prediction/planning

checkpoint.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d50f6ce46e3c7fd15d43238d2ee8e166611d29da422f197f2c677951ca4de72
+size 21717737

config.json

@@ -0,0 +1,21 @@
+{
+  "horizon": 16,
+  "action_dim": 2,
+  "state_dim": 4,
+  "goal_dim": 2,
+  "num_diffusion_steps": 100,
+  "down_dims": [
+    64,
+    128,
+    256
+  ],
+  "batch_size": 32,
+  "total_steps": 8000,
+  "lr": 0.0002,
+  "weight_decay": 1e-05,
+  "warmup_steps": 200,
+  "grad_clip": 10.0,
+  "eval_freq": 2000,
+  "log_freq": 25,
+  "hub_model_id": "precison9/human-like-robot-nav-diffusion"
+}

model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58f73f5200f793fce5cb88b4c4ebcf7b8eea843b5f29b8772b96de55a8082a89
+size 7229289

model_architecture.py

@@ -0,0 +1,545 @@
+"""
+CPU-optimized training for Human-Like Robot Navigation Trajectory Generator.
+Adapted for CPU sandbox with smaller UNet dims but same architecture.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import math
+import json
+import os
+import time
+from pathlib import Path
+
+# ═══════════════════════════════════════════════════════════════════════
+# DATA GENERATION (same as before)
+# ═══════════════════════════════════════════════════════════════════════
+
+AREA_SIZE = 20.0
+NUM_EPISODES = 2000
+MIN_STEPS = 40
+MAX_STEPS = 120
+DT = 0.1
+PREFERRED_SPEED = 1.3
+MAX_SPEED = 2.0
+MIN_SPEED = 0.3
+
+OBSTACLES = [
+    (5, 5, 1.5), (15, 10, 2.0), (10, 15, 1.0), (3, 12, 1.2),
+    (17, 4, 1.8), (8, 8, 0.8), (12, 3, 1.0), (6, 17, 1.5),
+]
+
+def social_force(pos, vel, goal, obstacles, walls_min=0.0, walls_max=AREA_SIZE):
+    force = np.zeros(2)
+    goal_dir = goal - pos
+    goal_dist = np.linalg.norm(goal_dir)
+    if goal_dist > 0.1:
+        desired_vel = PREFERRED_SPEED * goal_dir / goal_dist
+        force += (desired_vel - vel) / 0.5
+    for ox, oy, r in obstacles:
+        diff = pos - np.array([ox, oy])
+        dist = np.linalg.norm(diff) - r
+        if dist < 5.0 and dist > 0.01:
+            force += 3.0 * np.exp(-dist / 0.8) * diff / (np.linalg.norm(diff) + 1e-6)
+    wall_A, wall_B = 2.0, 0.5
+    if pos[0] < 3.0: force[0] += wall_A * np.exp(-(pos[0] - walls_min) / wall_B)
+    if pos[0] > AREA_SIZE - 3.0: force[0] -= wall_A * np.exp(-(walls_max - pos[0]) / wall_B)
+    if pos[1] < 3.0: force[1] += wall_A * np.exp(-(pos[1] - walls_min) / wall_B)
+    if pos[1] > AREA_SIZE - 3.0: force[1] -= wall_A * np.exp(-(walls_max - pos[1]) / wall_B)
+    return force
+
+def generate_episode():
+    for _ in range(100):
+        start = np.random.uniform(1.5, AREA_SIZE - 1.5, 2)
+        goal = np.random.uniform(1.5, AREA_SIZE - 1.5, 2)
+        if np.linalg.norm(goal - start) < 5.0: continue
+        valid = all(np.linalg.norm(start - [ox, oy]) >= r + 0.5 and 
+                    np.linalg.norm(goal - [ox, oy]) >= r + 0.5 for ox, oy, r in OBSTACLES)
+        if valid: break
+    pos = start.copy()
+    heading = np.arctan2(goal[1]-start[1], goal[0]-start[0]) + np.random.randn() * 0.3
+    vel = np.array([np.cos(heading), np.sin(heading)]) * MIN_SPEED
+    positions, velocities, actions = [pos.copy()], [vel.copy()], []
+    has_wp = np.random.random() < 0.4
+    mid = np.clip((start+goal)/2 + np.random.randn(2)*3, 1.5, AREA_SIZE-1.5) if has_wp else goal
+    wp_reached = not has_wp
+    cur_goal = mid if not wp_reached else goal
+    for step in range(np.random.randint(MIN_STEPS, MAX_STEPS+1)):
+        if not wp_reached and np.linalg.norm(pos - mid) < 1.5:
+            wp_reached = True; cur_goal = goal
+        force = social_force(pos, vel, cur_goal, OBSTACLES)
+        spd = np.linalg.norm(vel)
+        sway = np.array([-vel[1], vel[0]])/(spd+1e-6) * 0.05 * np.sin(2*np.pi*1.5*step*DT) if spd > 0.01 else np.zeros(2)
+        vel = vel + (force + sway + np.random.randn(2)*0.02) * DT
+        spd = np.linalg.norm(vel)
+        if spd > MAX_SPEED: vel = vel/spd*MAX_SPEED
+        elif spd < MIN_SPEED*0.5 and np.linalg.norm(pos-goal)>1: vel = vel/(spd+1e-6)*MIN_SPEED
+        gd = np.linalg.norm(pos - goal)
+        if gd < 2.0: vel *= max(0.1, gd/2.0)
+        new_pos = np.clip(pos + vel*DT, 0.1, AREA_SIZE-0.1)
+        actions.append((new_pos - pos).copy())
+        pos = new_pos; positions.append(pos.copy()); velocities.append(vel.copy())
+        if gd < 0.5: break
+    return {'positions': np.array(positions), 'velocities': np.array(velocities),
+            'actions': np.array(actions), 'goal': goal, 'num_steps': len(actions)}
+
+def build_dataset(data_dir='/app/dataset'):
+    np.random.seed(42); os.makedirs(data_dir, exist_ok=True)
+    all_s, all_a, all_g, all_ep, all_fr, all_ts, all_d = [], [], [], [], [], [], []
+    ve = 0
+    print("Generating trajectories...")
+    for _ in range(NUM_EPISODES):
+        ep = generate_episode()
+        if ep['num_steps'] < 10: continue
+        for t in range(ep['num_steps']):
+            all_s.append(np.concatenate([ep['positions'][t], ep['velocities'][t]]).tolist())
+            all_a.append(ep['actions'][t].tolist())
+            all_g.append(ep['goal'].tolist())
+            all_ep.append(ve); all_fr.append(t); all_ts.append(t*DT)
+            all_d.append(t == ep['num_steps']-1)
+        ve += 1
+        if ve % 500 == 0: print(f"  {ve} episodes...")
+    for name, arr, dt in [('observation_state', all_s, np.float32), ('action', all_a, np.float32),
+                           ('observation_goal', all_g, np.float32), ('episode_index', all_ep, np.int64),
+                           ('frame_index', all_fr, np.int64), ('timestamp', all_ts, np.float32)]:
+        np.save(f'{data_dir}/{name}.npy', np.array(arr, dtype=dt))
+    np.save(f'{data_dir}/done.npy', np.array(all_d, dtype=bool))
+    print(f"Dataset: {ve} episodes, {len(all_s)} frames")
+
+# ═══════════════════════════════════════════════════════════════════════
+# MODEL (same architecture, CPU-optimized dims)
+# ═══════════════════════════════════════════════════════════════════════
+
+class CosineNoiseScheduler:
+    def __init__(self, T=100, s=0.008):
+        self.T = T
+        t = torch.linspace(0, T, T+1)
+        ac = torch.cos(((t/T)+s)/(1+s)*math.pi*0.5)**2
+        ac = ac/ac[0]
+        betas = torch.clamp(1-(ac[1:]/ac[:-1]), 0.0001, 0.999)
+        alphas = 1.0-betas
+        ac = torch.cumprod(alphas, 0)
+        ac_prev = F.pad(ac[:-1], (1,0), value=1.0)
+        self.betas = betas
+        self.sqrt_ac = torch.sqrt(ac)
+        self.sqrt_1mac = torch.sqrt(1.0-ac)
+        self.sqrt_ra = torch.sqrt(1.0/alphas)
+        self.pv = betas*(1.0-ac_prev)/(1.0-ac)
+    
+    def add_noise(self, x0, noise, t):
+        sa = self.sqrt_ac[t].view(-1,1,1)
+        sm = self.sqrt_1mac[t].view(-1,1,1)
+        return (sa*x0 + sm*noise)
+    
+    def step(self, pred, t, xt):
+        b = self.betas[t].view(-1,1,1).to(xt.device)
+        sm = self.sqrt_1mac[t].view(-1,1,1).to(xt.device)
+        sr = self.sqrt_ra[t].view(-1,1,1).to(xt.device)
+        mean = sr*(xt - b*pred/sm)
+        if t[0]==0: return mean
+        v = self.pv[t].view(-1,1,1).to(xt.device)
+        return mean + torch.sqrt(v)*torch.randn_like(xt)
+
+class SinEmb(nn.Module):
+    def __init__(self, d):
+        super().__init__(); self.d = d
+    def forward(self, t):
+        h = self.d//2
+        e = math.log(10000)/(h-1)
+        e = torch.exp(torch.arange(h, device=t.device)*-e)
+        e = t[:,None].float()*e[None,:]
+        return torch.cat([e.sin(), e.cos()], -1)
+
+class FiLM(nn.Module):
+    def __init__(self, cd, fd):
+        super().__init__()
+        self.s = nn.Linear(cd, fd); self.b = nn.Linear(cd, fd)
+    def forward(self, x, c):
+        return x*(1+self.s(c).unsqueeze(-1))+self.b(c).unsqueeze(-1)
+
+class ResBlock(nn.Module):
+    def __init__(self, ic, oc, cd, ks=5, g=8):
+        super().__init__()
+        p = ks//2
+        self.c1 = nn.Conv1d(ic, oc, ks, padding=p)
+        self.c2 = nn.Conv1d(oc, oc, ks, padding=p)
+        self.n1 = nn.GroupNorm(min(g,oc), oc)
+        self.n2 = nn.GroupNorm(min(g,oc), oc)
+        self.film = FiLM(cd, oc)
+        self.act = nn.Mish()
+        self.skip = nn.Conv1d(ic, oc, 1) if ic!=oc else nn.Identity()
+    def forward(self, x, c):
+        h = self.act(self.n1(self.c1(x)))
+        h = self.film(h, c)
+        h = self.act(self.n2(self.c2(h)))
+        return h + self.skip(x)
+
+class TrajUNet(nn.Module):
+    def __init__(self, ad=2, sd=4, gd=2, H=16, dims=(128,256,512), emb_d=64, ks=5, ng=8):
+        super().__init__()
+        self.cond_enc = nn.Sequential(nn.Linear(sd+gd, 128), nn.Mish(), nn.Linear(128, 128), nn.Mish())
+        self.time_enc = nn.Sequential(SinEmb(emb_d), nn.Linear(emb_d, emb_d*2), nn.Mish(), nn.Linear(emb_d*2, emb_d))
+        cd = 128+emb_d
+        self.inp = nn.Conv1d(ad, dims[0], 1)
+        self.down_b = nn.ModuleList([ResBlock(dims[i], dims[i], cd, ks, ng) for i in range(len(dims)-1)])
+        self.down_p = nn.ModuleList([nn.Conv1d(dims[i], dims[i+1], 3, 2, 1) for i in range(len(dims)-1)])
+        self.mid = ResBlock(dims[-1], dims[-1], cd, ks, ng)
+        self.up_c = nn.ModuleList([nn.ConvTranspose1d(dims[i], dims[i-1], 4, 2, 1) for i in range(len(dims)-1, 0, -1)])
+        self.up_b = nn.ModuleList([ResBlock(dims[i-1]*2, dims[i-1], cd, ks, ng) for i in range(len(dims)-1, 0, -1)])
+        self.out = nn.Sequential(nn.Conv1d(dims[0], dims[0], ks, padding=ks//2), nn.Mish(), nn.Conv1d(dims[0], ad, 1))
+    
+    def forward(self, na, t, s, g):
+        c = torch.cat([self.cond_enc(torch.cat([s,g],-1)), self.time_enc(t)], -1)
+        x = self.inp(na.permute(0,2,1))
+        sk = []
+        for b, p in zip(self.down_b, self.down_p):
+            x = b(x, c); sk.append(x); x = p(x)
+        x = self.mid(x, c)
+        for uc, ub, s_ in zip(self.up_c, self.up_b, reversed(sk)):
+            x = uc(x)
+            if x.shape[-1] != s_.shape[-1]: x = F.pad(x, (0, s_.shape[-1]-x.shape[-1]))
+            x = ub(torch.cat([x, s_], 1), c)
+        return self.out(x).permute(0,2,1)
+
+class HumanTrajDiffusion(nn.Module):
+    def __init__(self, ad=2, sd=4, gd=2, H=16, T=100, dims=(128,256,512)):
+        super().__init__()
+        self.H = H; self.ad = ad; self.T = T
+        self.unet = TrajUNet(ad, sd, gd, H, dims)
+        self.sched = CosineNoiseScheduler(T)
+    
+    def forward(self, actions, state, goal):
+        B = actions.shape[0]
+        t = torch.randint(0, self.T, (B,), device=actions.device)
+        noise = torch.randn_like(actions)
+        noisy = self.sched.add_noise(actions, noise, t.cpu()).to(actions.device)
+        return F.mse_loss(self.unet(noisy, t, state, goal), noise)
+    
+    @torch.no_grad()
+    def generate(self, state, goal, n=1):
+        if state.dim()==1: state=state.unsqueeze(0)
+        if goal.dim()==1: goal=goal.unsqueeze(0)
+        dev = state.device
+        if n>1: state=state.repeat(n,1); goal=goal.repeat(n,1)
+        B = state.shape[0]
+        x = torch.randn(B, self.H, self.ad, device=dev)
+        for tv in reversed(range(self.T)):
+            t = torch.full((B,), tv, device=dev, dtype=torch.long)
+            x = self.sched.step(self.unet(x, t, state, goal), t.cpu(), x)
+        return x
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# DATASET
+# ═══════════════════════════════════════════════════════════════════════
+
+class TrajDS(torch.utils.data.Dataset):
+    def __init__(self, dd='/app/dataset', H=16):
+        self.H = H
+        self.states = np.load(f'{dd}/observation_state.npy')
+        self.actions = np.load(f'{dd}/action.npy')
+        self.goals = np.load(f'{dd}/observation_goal.npy')
+        self.eps = np.load(f'{dd}/episode_index.npy')
+        self.sm, self.ss = self.states.mean(0), self.states.std(0)+1e-6
+        self.am, self.as_ = self.actions.mean(0), self.actions.std(0)+1e-6
+        self.gm, self.gs = self.goals.mean(0), self.goals.std(0)+1e-6
+        vi = []
+        for e in np.unique(self.eps):
+            ei = np.where(self.eps==e)[0]
+            for i in range(len(ei)-H):
+                if ei[i+H-1]-ei[i]==H-1: vi.append(ei[i])
+        self.vi = np.array(vi)
+        print(f"Dataset: {len(self.vi)} samples")
+    def __len__(self): return len(self.vi)
+    def __getitem__(self, i):
+        s = self.vi[i]
+        return {
+            'state': torch.tensor((self.states[s]-self.sm)/self.ss, dtype=torch.float32),
+            'goal': torch.tensor((self.goals[s]-self.gm)/self.gs, dtype=torch.float32),
+            'actions': torch.tensor((self.actions[s:s+self.H]-self.am)/self.as_, dtype=torch.float32),
+        }
+    def stats(self):
+        return {k: getattr(self, k).tolist() for k in ['sm','ss','am','as_','gm','gs']}
+    def stats_named(self):
+        return {'state_mean': self.sm.tolist(), 'state_std': self.ss.tolist(),
+                'action_mean': self.am.tolist(), 'action_std': self.as_.tolist(),
+                'goal_mean': self.gm.tolist(), 'goal_std': self.gs.tolist()}
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# TRAINING
+# ═══════════════════════════════════════════════════════════════════════
+
+def cosine_lr(opt, step, total, warmup=300, lo=1e-6, hi=2e-4):
+    if step < warmup: lr = hi*step/warmup
+    else: lr = lo + (hi-lo)*0.5*(1+math.cos(math.pi*(step-warmup)/(total-warmup)))
+    for pg in opt.param_groups: pg['lr'] = lr
+    return lr
+
+def train():
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    print(f"Device: {device}")
+    
+    cfg = {
+        'horizon': 16, 'action_dim': 2, 'state_dim': 4, 'goal_dim': 2,
+        'num_diffusion_steps': 100, 'down_dims': [64, 128, 256],
+        'batch_size': 32, 'total_steps': 8000,
+        'lr': 2e-4, 'weight_decay': 1e-5, 'warmup_steps': 200,
+        'grad_clip': 10.0, 'eval_freq': 2000, 'log_freq': 25,
+        'hub_model_id': 'precison9/human-like-robot-nav-diffusion',
+    }
+    
+    # Init trackio
+    try:
+        import trackio
+        sid = os.environ.get('TRACKIO_SPACE_ID')
+        proj = os.environ.get('TRACKIO_PROJECT', 'human-like-robot-nav')
+        trackio.init(space_id=sid, project=proj, run="ddpm-traj-cpu-v1", config=cfg)
+        HAS_T = True
+        print(f"Trackio: {sid}/{proj}")
+    except:
+        HAS_T = False
+        print("No trackio")
+    
+    # Generate data if needed
+    if not os.path.exists('/app/dataset/observation_state.npy'):
+        build_dataset()
+    
+    torch.manual_seed(42); np.random.seed(42)
+    ds = TrajDS('/app/dataset', cfg['horizon'])
+    dl = torch.utils.data.DataLoader(ds, batch_size=cfg['batch_size'], shuffle=True,
+                                      num_workers=0, pin_memory=False, drop_last=True)
+    
+    model = HumanTrajDiffusion(ad=2, sd=4, gd=2, H=16, T=100,
+                                dims=tuple(cfg['down_dims'])).to(device)
+    npar = sum(p.numel() for p in model.parameters())
+    print(f"Model: {npar:,} params ({npar/1e6:.1f}M)")
+    
+    opt = torch.optim.AdamW(model.parameters(), lr=cfg['lr'], betas=(0.95,0.999),
+                             weight_decay=cfg['weight_decay'])
+    
+    model.train()
+    step = 0; rl = 0.0; best = float('inf'); t0 = time.time()
+    
+    print(f"\n{'='*60}\nTraining {cfg['total_steps']} steps on {device}\n{'='*60}\n")
+    
+    while step < cfg['total_steps']:
+        for batch in dl:
+            if step >= cfg['total_steps']: break
+            s, g, a = batch['state'].to(device), batch['goal'].to(device), batch['actions'].to(device)
+            lr = cosine_lr(opt, step, cfg['total_steps'], cfg['warmup_steps'], 1e-6, cfg['lr'])
+            loss = model(a, s, g)
+            opt.zero_grad(); loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), cfg['grad_clip'])
+            opt.step()
+            rl += loss.item(); step += 1
+            
+            if step % cfg['log_freq'] == 0:
+                al = rl/cfg['log_freq']; el = time.time()-t0; sps = step/el
+                print(f"step={step:5d} | loss={al:.6f} | lr={lr:.2e} | {sps:.1f} stp/s | eta={((cfg['total_steps']-step)/sps)/60:.1f}m")
+                if HAS_T: trackio.log({'train/loss': al, 'train/lr': lr})
+                rl = 0.0
+            
+            if step % cfg['eval_freq'] == 0:
+                model.eval()
+                els = []
+                idx = np.random.choice(len(ds), min(1280, len(ds)), replace=False)
+                for i in range(0, len(idx), cfg['batch_size']):
+                    bi = [ds[j] for j in idx[i:i+cfg['batch_size']]]
+                    if len(bi)<2: continue
+                    with torch.no_grad():
+                        els.append(model(
+                            torch.stack([x['actions'] for x in bi]).to(device),
+                            torch.stack([x['state'] for x in bi]).to(device),
+                            torch.stack([x['goal'] for x in bi]).to(device)).item())
+                el = np.mean(els)
+                print(f"  >>> EVAL step={step}: loss={el:.6f}")
+                if HAS_T: trackio.log({'eval/loss': el})
+                if el < best:
+                    best = el
+                    save(model, opt, step, cfg, ds, '/app/checkpoints/best')
+                    if HAS_T: trackio.alert("Best", f"eval={el:.6f} step={step}", level="INFO")
+                model.train()
+    
+    # Final save
+    save(model, opt, step, cfg, ds, '/app/checkpoints/final')
+    print(f"\nDone! Best eval: {best:.6f}")
+    if HAS_T: trackio.alert("Done", f"steps={step}, best={best:.6f}", level="INFO")
+    
+    # Eval generation
+    eval_gen(model, ds, device)
+    
+    # Push
+    push(cfg, ds)
+
+def save(model, opt, step, cfg, ds, path):
+    os.makedirs(path, exist_ok=True)
+    torch.save(model.state_dict(), f'{path}/model.pt')
+    torch.save({'step':step, 'model':model.state_dict(), 'opt':opt.state_dict()}, f'{path}/checkpoint.pt')
+    with open(f'{path}/config.json','w') as f: json.dump(cfg, f, indent=2)
+    with open(f'{path}/normalization_stats.json','w') as f: json.dump(ds.stats_named(), f, indent=2)
+    print(f"  Saved: {path}")
+
+def eval_gen(model, ds, device):
+    model.eval()
+    st = ds.stats_named()
+    cases = [
+        ([2,2,0.5,0.5], [18,18]), ([2,18,0.3,-0.3], [18,2]),
+        ([10,2,0,0.5], [10,18]), ([5,5,0.3,0.3], [15,15]),
+    ]
+    print(f"\n{'='*60}\nGeneration Evaluation\n{'='*60}")
+    all_spd = []
+    for i, (s_raw, g_raw) in enumerate(cases):
+        s_raw, g_raw = np.array(s_raw, np.float32), np.array(g_raw, np.float32)
+        sn = torch.tensor((s_raw-np.array(st['state_mean']))/np.array(st['state_std']), dtype=torch.float32).to(device)
+        gn = torch.tensor((g_raw-np.array(st['goal_mean']))/np.array(st['goal_std']), dtype=torch.float32).to(device)
+        trajs = model.generate(sn, gn, n=5).cpu().numpy()
+        td = trajs*np.array(st['action_std'])+np.array(st['action_mean'])
+        pos = np.cumsum(td, axis=1) + s_raw[:2]
+        speeds = np.linalg.norm(td, axis=-1)/DT
+        all_spd.extend(speeds.flatten().tolist())
+        div = np.std(pos[:,-1], axis=0).mean()
+        print(f"  Case {i+1}: {s_raw[:2].tolist()} → {g_raw.tolist()} | "
+              f"speed={speeds.mean():.2f}m/s | diversity={div:.3f}m")
+    
+    print(f"\n  Overall mean speed: {np.mean(all_spd):.2f} m/s (human: ~1.3 m/s)")
+    print(f"  Speed std: {np.std(all_spd):.2f} m/s")
+
+def push(cfg, ds):
+    from huggingface_hub import HfApi
+    hid = cfg['hub_model_id']
+    bp = Path('/app/checkpoints/best')
+    fp = Path('/app/checkpoints/final')
+    up = bp if bp.exists() else fp
+    if not up.exists(): print("No checkpoint!"); return
+    
+    api = HfApi()
+    try: api.create_repo(hid, exist_ok=True)
+    except Exception as e: print(f"Repo: {e}")
+    
+    st = ds.stats_named()
+    np_ = sum(v.numel() for v in torch.load(up/'model.pt', map_location='cpu', weights_only=True).values())
+    
+    readme = f"""---
+tags:
+- robotics
+- trajectory-generation
+- diffusion-model
+- navigation
+- human-like-motion
+- ddpm
+library_name: pytorch
+pipeline_tag: reinforcement-learning
+license: mit
+---
+
+# 🤖🚶 Human-Like Robot Navigation Trajectory Generator
+
+A **DDPM (Denoising Diffusion Probabilistic Model)** that generates human-like 2D navigation trajectories for robots.
+
+## What It Does
+
+Given a robot's current state (position + velocity) and a goal, this model generates future waypoints that mimic human walking — smooth curves, natural speed changes, and obstacle-aware paths.
+
+```
+Input:  [x, y, vx, vy] + [goal_x, goal_y]
+  ↓ DDPM Reverse Diffusion (100 steps)
+  ↓ 1D Temporal UNet + FiLM conditioning
+Output: 16 future waypoints [dx, dy]
+```
+
+## Key Features
+
+- 🚶 **Human-like paths** — smooth curves, not robotic straight lines
+- ⚡ **Variable speed** — acceleration, cruising, deceleration like real walking
+- 🧱 **Obstacle aware** — learned from social force model training data
+- 🎲 **Multi-modal** — generates diverse trajectory samples via diffusion
+- 🎯 **Goal-directed** — conditions on target position
+
+## Architecture
+
+| Component | Details |
+|-----------|---------|
+| Backbone | 1D Temporal UNet ({cfg['down_dims']}) |
+| Conditioning | FiLM (Feature-wise Linear Modulation) |
+| Noise Schedule | Cosine (Improved DDPM) |
+| Diffusion Steps | {cfg['num_diffusion_steps']} |
+| Parameters | {np_:,} ({np_/1e6:.1f}M) |
+| Prediction | ε-prediction (noise) |
+
+## Based On
+
+- [Diffusion Policy](https://arxiv.org/abs/2303.04137) (Chi et al., RSS 2023)
+- [TRACE](https://arxiv.org/abs/2304.01893) (Rempe et al., CVPR 2023)
+- [Improved DDPM](https://arxiv.org/abs/2102.09672) (Nichol & Dhariwal, 2021)
+
+## Training Data
+
+2,000 synthetic episodes in a 20m × 20m environment with 8 obstacles:
+- Social Force Model physics (Helbing & Molnar 1995)
+- ~156K frames at 10 Hz
+- Speed range: 0.3-2.0 m/s (avg ~1.3 m/s, matching human walking)
+
+## Quick Start
+
+```python
+import torch, json, numpy as np
+
+# Load
+config = json.load(open('config.json'))
+stats = json.load(open('normalization_stats.json'))
+
+# Build model (copy architecture classes from this repo)
+model = HumanTrajDiffusion(ad=2, sd=4, gd=2, H=16, T=100, dims=tuple(config['down_dims']))
+model.load_state_dict(torch.load('model.pt', map_location='cpu'))
+model.eval()
+
+# Robot at (5,5) moving NE → goal (15,15)
+state = np.array([5.0, 5.0, 0.5, 0.3])
+goal = np.array([15.0, 15.0])
+
+state_n = torch.tensor((state - stats['state_mean']) / stats['state_std'], dtype=torch.float32)
+goal_n = torch.tensor((goal - stats['goal_mean']) / stats['goal_std'], dtype=torch.float32)
+
+# Generate 5 diverse paths
+trajectories = model.generate(state_n, goal_n, n=5)
+
+# → Real coordinates
+traj = trajectories.numpy() * stats['action_std'] + stats['action_mean']
+positions = np.cumsum(traj, axis=1) + state[:2]
+# positions.shape = (5, 16, 2) — 5 paths, 16 waypoints, (x,y)
+```
+
+## Config
+```json
+{json.dumps(cfg, indent=2)}
+```
+
+## Normalization Stats
+```json
+{json.dumps(st, indent=2)}
+```
+
+## Applications
+- 🤖 Mobile robot navigation
+- 🎮 NPC pedestrian AI
+- 🏗️ Crowd simulation
+- 📊 Trajectory prediction/planning
+"""
+    with open(up/'README.md','w') as f: f.write(readme)
+    
+    # Also save model architecture code
+    model_code = open('/app/train_cpu.py').read()
+    with open(up/'model_architecture.py','w') as f: f.write(model_code)
+    
+    print(f"Pushing to: {hid}")
+    try:
+        api.upload_folder(folder_path=str(up), repo_id=hid, commit_message="Upload human-like robot nav model")
+        print(f"✅ https://huggingface.co/{hid}")
+    except Exception as e: print(f"Push error: {e}")
+
+
+if __name__ == '__main__':
+    train()

normalization_stats.json

@@ -0,0 +1,30 @@
+{
+  "state_mean": [
+    9.887735366821289,
+    10.40771484375,
+    0.02240574173629284,
+    -0.010746479965746403
+  ],
+  "state_std": [
+    4.021646976470947,
+    3.9589571952819824,
+    0.7364981174468994,
+    0.7464056015014648
+  ],
+  "action_mean": [
+    0.0022544937673956156,
+    -0.001080495654605329
+  ],
+  "action_std": [
+    0.07394769042730331,
+    0.07494954019784927
+  ],
+  "goal_mean": [
+    10.106578826904297,
+    10.3273344039917
+  ],
+  "goal_std": [
+    4.950056076049805,
+    5.060120582580566
+  ]
+}