Upload folder using huggingface_hub

DO_THIS_NOW.md

@@ -0,0 +1,139 @@
+# ⚡ DO THIS NOW - Immediate Debugging Steps
+
+## Your Problem
+- Gave prompt on HF Space
+- Took long time
+- Finally showed error
+
+---
+
+## 🎯 Run These 2 Commands (Takes 1 minute)
+
+### Command 1: Check HF Space Status
+```powershell
+python debug_hf_space.py
+```
+
+**This tells you:**
+- Is your Space running?
+- Using CPU or GPU?
+- Are models uploaded?
+
+### Command 2: Check What Error Actually Happened
+
+**Manual step (30 seconds):**
+1. Go to: https://huggingface.co/spaces/nocapdev/my-gradio-momask/logs
+2. Scroll to the **BOTTOM**
+3. Look for lines with **ERROR** or **Exception**
+4. Copy the last 30 lines
+
+---
+
+## 📋 Share These Results
+
+After running the commands above, you'll see one of these scenarios:
+
+### Scenario A: Models Missing ❌
+```
+⚠️  NO checkpoint files found!
+ERROR: Model checkpoints not found!
+```
+
+**Fix:**
+Upload your `checkpoints/` folder to HF Space (I'll show you how)
+
+### Scenario B: Using CPU (Slow but OK) ⏳
+```
+⚠️  Using CPU (FREE tier)
+• Generation time: 10-30 minutes per prompt
+```
+
+**Fix:**
+This is NORMAL! Just wait 20-30 minutes for first prompt.
+Or upgrade to GPU for 30x speed.
+
+### Scenario C: Out of Memory 💥
+```
+Killed
+SIGKILL
+OutOfMemoryError
+```
+
+**Fix:**
+Upgrade Space RAM or optimize model.
+
+### Scenario D: Other Error ❓
+```
+Some other error message...
+```
+
+**Fix:**
+Copy the full error and share it with me!
+
+---
+
+## 🚀 Quick Actions Based on Results
+
+### If models are missing:
+```powershell
+# I'll help you upload them - just let me know
+# We'll use Git LFS or HF web interface
+```
+
+### If using CPU (slow):
+**Option 1:** Wait it out (FREE)
+- Generation takes 15-30 minutes on CPU
+- This is NORMAL behavior
+
+**Option 2:** Upgrade to GPU
+- Go to Space Settings → Hardware
+- Select "T4 small GPU"
+- Costs ~$0.60/hour
+- 30x faster (30 seconds vs 30 minutes)
+
+### If out of memory:
+```powershell
+# Upgrade hardware in Space Settings
+# Or we can optimize the code
+```
+
+---
+
+## 📊 What to Share
+
+Run this and copy the output:
+```powershell
+python debug_hf_space.py
+```
+
+Then go to HF Logs and copy:
+- Last 30-50 lines
+- Any lines with "ERROR"
+- Any lines with "Exception" or "Traceback"
+
+Share both and I'll give you the exact fix!
+
+---
+
+## ⏱️ This Takes 2 Minutes
+
+1. **Run:** `python debug_hf_space.py` (30 seconds)
+2. **Visit:** Logs tab on HF Space (30 seconds)
+3. **Copy:** Error messages (30 seconds)
+4. **Share:** Results here (30 seconds)
+
+Then I can tell you EXACTLY what to fix!
+
+---
+
+## 🎯 Most Likely: One of These Two
+
+**90% chance it's one of:**
+
+1. **Models not uploaded to HF Space**
+   - Fix: Upload checkpoints folder
+
+2. **Using CPU so it's very slow**
+   - Fix: Wait longer OR upgrade to GPU
+
+The debug script will tell you which one!

GET_ERROR_LOGS.md

@@ -0,0 +1,131 @@
+# 📋 How to Get Your Error Logs
+
+Since you saw an error, here's how to get the details:
+
+## Step 1: Visit Your Space Logs
+
+**Click this link:**
+https://huggingface.co/spaces/nocapdev/my-gradio-momask/logs
+
+## Step 2: What to Look For
+
+Scroll through the logs and find:
+
+### A. Startup Messages
+Look for:
+```
+Using device: cpu
+Loading models...
+Models loaded successfully!
+```
+
+**OR error messages like:**
+```
+ERROR: Model checkpoints not found!
+FileNotFoundError: ...
+```
+
+### B. When You Submitted the Prompt
+Look for:
+```
+Generating motion for: 'your prompt here'
+[1/4] Generating motion tokens...
+```
+
+**What happened after this?**
+- Did it get stuck?
+- Did it show an error?
+- Did it say "Killed"?
+
+### C. Any ERROR Lines
+Search for (Ctrl+F):
+- `ERROR`
+- `Exception`
+- `Traceback`
+- `Killed`
+- `SIGKILL`
+
+## Step 3: Copy These Sections
+
+Copy and share:
+
+1. **Lines showing device and model loading** (first 20 lines)
+2. **Lines when you submitted your prompt** (around your text)
+3. **Any ERROR or Exception messages** (full traceback)
+4. **The last 20 lines** of the log
+
+## Quick Copy Template
+
+Share this format:
+
+```
+=== STARTUP ===
+[First 20 lines from logs showing "Using device" and "Loading models"]
+
+=== WHEN I SUBMITTED PROMPT ===
+[Lines showing "Generating motion for: 'your prompt'"]
+[What happened next]
+
+=== ERROR (if any) ===
+[Any ERROR or Exception messages]
+
+=== LAST 20 LINES ===
+[Last 20 lines from the bottom]
+```
+
+---
+
+## Common Patterns to Look For
+
+### Pattern 1: Models Missing
+```
+ERROR: Model checkpoints not found!
+Looking for: ./checkpoints
+FileNotFoundError: [Errno 2] No such file or directory
+```
+**→ Models weren't uploaded to HF Space**
+
+### Pattern 2: Using CPU (Slow but Normal)
+```
+Using device: cpu
+[1/4] Generating motion tokens...
+[stuck here for 20 minutes]
+```
+**→ CPU is slow, wait 30 mins OR upgrade to GPU**
+
+### Pattern 3: Out of Memory
+```
+Killed
+Process finished with exit code 137
+```
+**→ Ran out of RAM**
+
+### Pattern 4: Import Error
+```
+ModuleNotFoundError: No module named 'xxx'
+ImportError: cannot import name 'xxx'
+```
+**→ Missing dependency**
+
+---
+
+## Fast Way (if token is set)
+
+If you have HUGGINGFACE_TOKEN set:
+```powershell
+python simple_check.py
+```
+
+This shows:
+- Space status (Running/Stopped)
+- Hardware (CPU/GPU)
+- If checkpoints exist
+
+---
+
+## What to Share
+
+Just copy the logs and share them here. I'll identify the exact issue and give you the fix!
+
+**Direct link to logs:**
+https://huggingface.co/spaces/nocapdev/my-gradio-momask/logs

HOW_TO_DEBUG.md

@@ -0,0 +1,284 @@
+# 🐛 How to Debug Your HF Space
+
+## Your Situation
+✅ Deployed successfully
+⏳ Took long time to respond
+❌ Finally showed error
+
+---
+
+## 🎯 Step-by-Step Debugging
+
+### Step 1: Run Local Diagnosis (30 seconds)
+
+```powershell
+# Check your HF Space status
+python debug_hf_space.py
+```
+
+This will tell you:
+- ✅ If Space is running
+- ✅ What hardware it's using (CPU vs GPU)
+- ✅ If model files are uploaded
+- ✅ Common issues
+
+### Step 2: Get the Actual Error (MOST IMPORTANT)
+
+Go to your Space and copy the error:
+
+1. **Visit:** https://huggingface.co/spaces/nocapdev/my-gradio-momask
+2. **Click:** "Logs" tab (top right)
+3. **Scroll** to the bottom
+4. **Copy** the last 30-50 lines
+
+**What to look for:**
+- Lines with `ERROR` or `Exception`
+- Lines with `Traceback`
+- The very last error message
+
+### Step 3: Common Error Patterns
+
+#### Error A: "Model checkpoints not found"
+```
+ERROR: Model checkpoints not found!
+Looking for: ./checkpoints
+FileNotFoundError: [Errno 2] No such file or directory
+```
+
+**Cause:** Model files weren't uploaded to HF Space
+**Solution:** Upload the checkpoints (see below)
+
+#### Error B: "CUDA out of memory"
+```
+RuntimeError: CUDA out of memory
+torch.cuda.OutOfMemoryError
+```
+
+**Cause:** Model too large for GPU RAM
+**Solution:** Use larger GPU or optimize model
+
+#### Error C: "Killed" or "SIGKILL"
+```
+Killed
+Process finished with exit code 137
+```
+
+**Cause:** Out of RAM (CPU memory)
+**Solution:** Upgrade Space RAM or optimize code
+
+#### Error D: Stuck at "Generating motion tokens..."
+```
+[1/4] Generating motion tokens...
+[No more output for 20+ minutes]
+```
+
+**Cause:** Using CPU (very slow, not an error!)
+**Solution:** Wait 20-30 minutes OR upgrade to GPU
+
+---
+
+## 🔧 Solutions for Common Issues
+
+### Solution 1: Upload Model Checkpoints
+
+**If error shows:** `Model checkpoints not found`
+
+#### Option A: Upload via Git (for files <10GB)
+
+```bash
+# Clone your Space
+git clone https://huggingface.co/spaces/nocapdev/my-gradio-momask
+cd my-gradio-momask
+
+# Install Git LFS (one time)
+git lfs install
+
+# Track large files
+git lfs track "checkpoints/**/*.tar"
+git lfs track "checkpoints/**/*.pth"
+git lfs track "checkpoints/**/*.npy"
+
+# Copy your checkpoints
+# FROM: C:\Users\purva\OneDrive\Desktop\momaskhg\checkpoints
+# TO: current directory
+cp -r /path/to/checkpoints ./
+
+# Commit and push
+git add .gitattributes
+git add checkpoints/
+git commit -m "Add model checkpoints"
+git push
+```
+
+#### Option B: Upload via HF Web UI
+
+1. Go to: https://huggingface.co/spaces/nocapdev/my-gradio-momask/tree/main
+2. Click "Add file" → "Upload files"
+3. Drag your `checkpoints/` folder
+4. Click "Commit"
+
+**Note:** This works for files <50MB. For larger files, use Git LFS.
+
+#### Option C: Host Models Separately
+
+Upload models to HF Model Hub, then download in app.py:
+
+```python
+from huggingface_hub import snapshot_download
+
+# Add to app.py before initializing generator
+if not os.path.exists('./checkpoints'):
+    print("Downloading models from HF Hub...")
+    snapshot_download(
+        repo_id="YOUR_USERNAME/momask-models",
+        local_dir="./checkpoints"
+    )
+```
+
+---
+
+### Solution 2: Upgrade Hardware (for speed)
+
+If using CPU and it's too slow:
+
+1. Go to: https://huggingface.co/spaces/nocapdev/my-gradio-momask/settings
+2. Scroll to "Hardware"
+3. Select:
+   - **T4 small** (~$0.60/hour) - Good for this app
+   - **A10G small** (~$3/hour) - Faster
+4. Click "Save"
+5. Wait for rebuild (~2 minutes)
+
+---
+
+### Solution 3: Test Locally First
+
+Before debugging on HF, test locally:
+
+```powershell
+# 1. Test your setup
+python test_local.py
+
+# 2. Run app locally
+python app.py
+
+# 3. Visit http://localhost:7860
+# 4. Try a prompt
+# 5. Check terminal for errors
+```
+
+**If it works locally but fails on HF:**
+- Models probably not uploaded to HF Space
+- Or HF Space using different Python/package versions
+
+---
+
+## 📋 Debugging Checklist
+
+Run through this checklist:
+
+### ✅ Pre-deployment
+- [ ] `python test_local.py` passes
+- [ ] App works locally at http://localhost:7860
+- [ ] Models in `./checkpoints/` directory
+- [ ] `python pre_deploy_check.py` shows 8/8 PASS
+
+### ✅ Post-deployment
+- [ ] Space shows "Running" status
+- [ ] Logs show "Using device: cpu/cuda"
+- [ ] Logs show "Models loaded successfully!"
+- [ ] No error messages in logs
+
+### ✅ During generation
+- [ ] Logs show "[1/4] Generating motion tokens..."
+- [ ] Logs show progress through [2/4], [3/4], [4/4]
+- [ ] No "Killed" or "SIGKILL" messages
+
+---
+
+## 🎯 Quick Diagnosis Commands
+
+```powershell
+# Check HF Space status
+python debug_hf_space.py
+
+# Test local setup
+python test_local.py
+
+# Validate before deploy
+python pre_deploy_check.py
+
+# Deploy with latest fixes
+python deploy.py
+```
+
+---
+
+## 📊 Expected Logs (Healthy Run)
+
+### Startup (should see this):
+```
+Using device: cpu  (or cuda)
+Loading models...
+✓ VQ model loaded
+✓ Transformer loaded
+✓ Residual model loaded
+✓ Length estimator loaded
+Models loaded successfully!
+Running on local URL: http://0.0.0.0:7860
+```
+
+### During generation (should see this):
+```
+======================================================================
+Generating motion for: 'a person walks forward'
+======================================================================
+[1/4] Generating motion tokens...
+✓ Generated 80 frames
+[2/4] Converting to BVH format...
+✓ BVH conversion complete
+[3/4] Rendering video...
+✓ Video saved to ./gradio_outputs/motion_12345.mp4
+[4/4] Complete!
+======================================================================
+```
+
+---
+
+## 🆘 Still Stuck?
+
+### Share these with me:
+
+1. **Output from:**
+   ```powershell
+   python debug_hf_space.py
+   ```
+
+2. **Last 50 lines from HF Space Logs**
+   - Go to Logs tab
+   - Copy from bottom
+   - Include any ERROR or Traceback
+
+3. **What you see in the browser**
+   - Screenshot of the error
+   - Or copy the error message
+
+Then I can give you the exact fix!
+
+---
+
+## 💡 Most Likely Issues (90% of cases)
+
+1. **CPU is slow** (not an error!)
+   - Logs show: "Using device: cpu"
+   - Solution: Wait 20 mins OR upgrade to GPU
+
+2. **Models not uploaded**
+   - Logs show: "Model checkpoints not found"
+   - Solution: Upload checkpoints to HF Space
+
+3. **Out of memory**
+   - Logs show: "Killed" or "SIGKILL"
+   - Solution: Upgrade to more RAM
+
+Run `python debug_hf_space.py` first - it will identify which one!

app.py

@@ -1,391 +1,440 @@
-import os
-from os.path import join as pjoin
-import gradio as gr
-import torch
-import torch.nn.functional as F
-import numpy as np
-from torch.distributions.categorical import Categorical
-
-from models.mask_transformer.transformer import MaskTransformer, ResidualTransformer
-from models.vq.model import RVQVAE, LengthEstimator
-from utils.get_opt import get_opt
-from utils.fixseed import fixseed
-from visualization.joints2bvh import Joint2BVHConvertor
-from utils.motion_process import recover_from_ric
-from utils.plot_script import plot_3d_motion
-from utils.paramUtil import t2m_kinematic_chain
-
-clip_version = 'ViT-B/32'
-
-class MotionGenerator:
-    def __init__(self, checkpoints_dir, dataset_name, model_name, res_name, vq_name, device='cuda'):
-        self.device = torch.device(device if torch.cuda.is_available() else 'cpu')
-        self.dataset_name = dataset_name
-        self.dim_pose = 251 if dataset_name == 'kit' else 263
-        self.nb_joints = 21 if dataset_name == 'kit' else 22
-        
-        # Load models
-        print("Loading models...")
-        self.vq_model, self.vq_opt = self._load_vq_model(checkpoints_dir, dataset_name, vq_name)
-        self.t2m_transformer = self._load_trans_model(checkpoints_dir, dataset_name, model_name)
-        self.res_model = self._load_res_model(checkpoints_dir, dataset_name, res_name, self.vq_opt)
-        self.length_estimator = self._load_len_estimator(checkpoints_dir, dataset_name)
-        
-        # Set to eval mode
-        self.vq_model.eval()
-        self.t2m_transformer.eval()
-        self.res_model.eval()
-        self.length_estimator.eval()
-        
-        # Load normalization stats
-        meta_dir = pjoin(checkpoints_dir, dataset_name, vq_name, 'meta')
-        self.mean = np.load(pjoin(meta_dir, 'mean.npy'))
-        self.std = np.load(pjoin(meta_dir, 'std.npy'))
-        
-        self.kinematic_chain = t2m_kinematic_chain
-        self.converter = Joint2BVHConvertor()
-        
-        print("Models loaded successfully!")
-    
-    def _load_vq_model(self, checkpoints_dir, dataset_name, vq_name):
-        vq_opt_path = pjoin(checkpoints_dir, dataset_name, vq_name, 'opt.txt')
-        vq_opt = get_opt(vq_opt_path, device=self.device)
-        vq_opt.dim_pose = self.dim_pose
-        
-        vq_model = RVQVAE(vq_opt,
-                    vq_opt.dim_pose,
-                    vq_opt.nb_code,
-                    vq_opt.code_dim,
-                    vq_opt.output_emb_width,
-                    vq_opt.down_t,
-                    vq_opt.stride_t,
-                    vq_opt.width,
-                    vq_opt.depth,
-                    vq_opt.dilation_growth_rate,
-                    vq_opt.vq_act,
-                    vq_opt.vq_norm)
-        
-        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, vq_name, 'model', 'net_best_fid.tar'),
-                                map_location=self.device)
-        model_key = 'vq_model' if 'vq_model' in ckpt else 'net'
-        vq_model.load_state_dict(ckpt[model_key])
-        vq_model.to(self.device)
-        
-        return vq_model, vq_opt
-    
-    def _load_trans_model(self, checkpoints_dir, dataset_name, model_name):
-        model_opt_path = pjoin(checkpoints_dir, dataset_name, model_name, 'opt.txt')
-        model_opt = get_opt(model_opt_path, device=self.device)
-        
-        model_opt.num_tokens = self.vq_opt.nb_code
-        model_opt.num_quantizers = self.vq_opt.num_quantizers
-        model_opt.code_dim = self.vq_opt.code_dim
-        
-        # Set default values for missing attributes
-        if not hasattr(model_opt, 'latent_dim'):
-            model_opt.latent_dim = 384
-        if not hasattr(model_opt, 'ff_size'):
-            model_opt.ff_size = 1024
-        if not hasattr(model_opt, 'n_layers'):
-            model_opt.n_layers = 8
-        if not hasattr(model_opt, 'n_heads'):
-            model_opt.n_heads = 6
-        if not hasattr(model_opt, 'dropout'):
-            model_opt.dropout = 0.1
-        if not hasattr(model_opt, 'cond_drop_prob'):
-            model_opt.cond_drop_prob = 0.1
-        
-        t2m_transformer = MaskTransformer(code_dim=model_opt.code_dim,
-                                          cond_mode='text',
-                                          latent_dim=model_opt.latent_dim,
-                                          ff_size=model_opt.ff_size,
-                                          num_layers=model_opt.n_layers,
-                                          num_heads=model_opt.n_heads,
-                                          dropout=model_opt.dropout,
-                                          clip_dim=512,
-                                          cond_drop_prob=model_opt.cond_drop_prob,
-                                          clip_version=clip_version,
-                                          opt=model_opt)
-        
-        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, model_name, 'model', 'latest.tar'),
-                          map_location=self.device)
-        model_key = 't2m_transformer' if 't2m_transformer' in ckpt else 'trans'
-        t2m_transformer.load_state_dict(ckpt[model_key], strict=False)
-        t2m_transformer.to(self.device)
-        
-        return t2m_transformer
-    
-    def _load_res_model(self, checkpoints_dir, dataset_name, res_name, vq_opt):
-        res_opt_path = pjoin(checkpoints_dir, dataset_name, res_name, 'opt.txt')
-        res_opt = get_opt(res_opt_path, device=self.device)
-        
-        # The res_name appears to be the same as vq_name, so res_opt is actually vq_opt
-        # We need to use proper model architecture parameters
-        res_opt.num_quantizers = vq_opt.num_quantizers
-        res_opt.num_tokens = vq_opt.nb_code
-        
-        # Set architecture parameters for ResidualTransformer
-        # These should match the main transformer architecture
-        res_opt.latent_dim = 384  # Match with main transformer
-        res_opt.ff_size = 1024
-        res_opt.n_layers = 9  # Typically slightly more layers for residual
-        res_opt.n_heads = 6
-        res_opt.dropout = 0.1
-        res_opt.cond_drop_prob = 0.1
-        res_opt.share_weight = False
-        
-        print(f"ResidualTransformer config - latent_dim: {res_opt.latent_dim}, ff_size: {res_opt.ff_size}, nlayers: {res_opt.n_layers}, nheads: {res_opt.n_heads}, dropout: {res_opt.dropout}")
-        
-        res_transformer = ResidualTransformer(code_dim=vq_opt.code_dim,
-                                                cond_mode='text',
-                                                latent_dim=res_opt.latent_dim,
-                                                ff_size=res_opt.ff_size,
-                                                num_layers=res_opt.n_layers,
-                                                num_heads=res_opt.n_heads,
-                                                dropout=res_opt.dropout,
-                                                clip_dim=512,
-                                                shared_codebook=vq_opt.shared_codebook,
-                                                cond_drop_prob=res_opt.cond_drop_prob,
-                                                share_weight=res_opt.share_weight,
-                                                clip_version=clip_version,
-                                                opt=res_opt)
-        
-        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, res_name, 'model', 'net_best_fid.tar'),
-                          map_location=self.device)
-        
-        # Debug: check available keys
-        print(f"Available checkpoint keys: {ckpt.keys()}")
-        
-        # Try different possible keys for the model state dict
-        model_key = None
-        for key in ['res_transformer', 'trans', 'net', 'model', 'state_dict']:
-            if key in ckpt:
-                model_key = key
-                break
-        
-        if model_key:
-            print(f"Loading ResidualTransformer from key: {model_key}")
-            res_transformer.load_state_dict(ckpt[model_key], strict=False)
-        else:
-            print("Warning: Could not find model weights in checkpoint. Available keys:", list(ckpt.keys()))
-            # If this is actually a VQ model checkpoint, we might need to skip loading or handle differently
-            if 'vq_model' in ckpt or 'net' in ckpt:
-                print("This appears to be a VQ model checkpoint, not a ResidualTransformer checkpoint.")
-                print("Skipping weight loading - using randomly initialized ResidualTransformer.")
-        
-        res_transformer.to(self.device)
-        
-        return res_transformer
-    
-    def _load_len_estimator(self, checkpoints_dir, dataset_name):
-        model = LengthEstimator(512, 50)
-        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, 'length_estimator', 'model', 'finest.tar'),
-                          map_location=self.device)
-        model.load_state_dict(ckpt['estimator'])
-        model.to(self.device)
-        return model
-    
-    def inv_transform(self, data):
-        return data * self.std + self.mean
-    
-    @torch.no_grad()
-    def generate(self, text_prompt, motion_length=0, time_steps=18, cond_scale=4, 
-                 temperature=1, topkr=0.9, gumbel_sample=True, seed=42):
-        """
-        Generate motion from text prompt
-        
-        Args:
-            text_prompt: Text description of the motion
-            motion_length: Desired motion length (0 for auto-estimation)
-            time_steps: Number of denoising steps
-            cond_scale: Classifier-free guidance scale
-            temperature: Sampling temperature
-            topkr: Top-k filtering threshold
-            gumbel_sample: Whether to use Gumbel sampling
-            seed: Random seed
-        """
-        fixseed(seed)
-        
-        # Convert motion_length to int if needed
-        if isinstance(motion_length, float):
-            motion_length = int(motion_length)
-        
-        # Estimate length if not provided
-        if motion_length == 0:
-            text_embedding = self.t2m_transformer.encode_text([text_prompt])
-            pred_dis = self.length_estimator(text_embedding)
-            probs = F.softmax(pred_dis, dim=-1)
-            token_lens = Categorical(probs).sample()
-        else:
-            token_lens = torch.LongTensor([motion_length // 4]).to(self.device)
-        
-        m_length = token_lens * 4
-        
-        # Generate motion tokens
-        mids = self.t2m_transformer.generate([text_prompt], token_lens,
-                                            timesteps=int(time_steps),
-                                            cond_scale=float(cond_scale),
-                                            temperature=float(temperature),
-                                            topk_filter_thres=float(topkr),
-                                            gsample=gumbel_sample)
-        
-        # Refine with residual transformer
-        mids = self.res_model.generate(mids, [text_prompt], token_lens, 
-                                      temperature=1, cond_scale=5)
-        
-        # Decode to motion
-        pred_motions = self.vq_model.forward_decoder(mids)
-        pred_motions = pred_motions.detach().cpu().numpy()
-        
-        # Denormalize
-        data = self.inv_transform(pred_motions)
-        joint_data = data[0, :m_length[0]]
-        
-        # Recover 3D joints
-        joint = recover_from_ric(torch.from_numpy(joint_data).float(), self.nb_joints).numpy()
-        
-        return joint, int(m_length[0].item())
-
-
-def create_gradio_interface(generator, output_dir='./gradio_outputs'):
-    os.makedirs(output_dir, exist_ok=True)
-    
-    def generate_motion(text_prompt):
-        try:
-            # Use default parameters for simplicity
-            motion_length = 0  # Auto-estimate
-            time_steps = 18
-            cond_scale = 4.0
-            temperature = 1.0
-            topkr = 0.9
-            use_gumbel = True
-            seed = 42
-            use_ik = True
-            
-            # Generate motion
-            joint, actual_length = generator.generate(
-                text_prompt, 
-                motion_length, 
-                time_steps, 
-                cond_scale,
-                temperature, 
-                topkr, 
-                use_gumbel, 
-                seed
-            )
-            
-            # Save BVH and video
-            timestamp = str(np.random.randint(100000))
-            video_path = pjoin(output_dir, f'motion_{timestamp}.mp4')
-            
-            # Convert to BVH with foot IK
-            _, joint_processed = generator.converter.convert(
-                joint, filename=None, iterations=100, foot_ik=True
-            )
-            
-            # Create video
-            plot_3d_motion(video_path, generator.kinematic_chain, joint_processed, 
-                          title=text_prompt, fps=20)
-            
-            return video_path
-        
-        except Exception as e:
-            import traceback
-            error_msg = f"Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
-            print(error_msg)
-            return None
-    
-    # Create Gradio interface with Blocks for custom layout
-    with gr.Blocks(theme=gr.themes.Base(
-        primary_hue="blue",
-        secondary_hue="gray",
-    ).set(
-        body_background_fill="*neutral_950",
-        body_background_fill_dark="*neutral_950",
-        background_fill_primary="*neutral_900",
-        background_fill_primary_dark="*neutral_900",
-        background_fill_secondary="*neutral_800",
-        background_fill_secondary_dark="*neutral_800",
-        block_background_fill="*neutral_900",
-        block_background_fill_dark="*neutral_900",
-        input_background_fill="*neutral_800",
-        input_background_fill_dark="*neutral_800",
-        button_primary_background_fill="*primary_600",
-        button_primary_background_fill_dark="*primary_600",
-        button_primary_text_color="white",
-        button_primary_text_color_dark="white",
-        block_label_text_color="*neutral_200",
-        block_label_text_color_dark="*neutral_200",
-        body_text_color="*neutral_200",
-        body_text_color_dark="*neutral_200",
-        input_placeholder_color="*neutral_500",
-        input_placeholder_color_dark="*neutral_500",
-    ),
-    css="""
-        footer {display: none !important;}
-        .video-fixed-height {
-            height: 600px !important;
-        }
-        .video-fixed-height video {
-            max-height: 600px !important;
-            object-fit: contain !important;
-        }
-    """) as demo:
-        
-        gr.Markdown("# 🎭 Text-to-Motion Generator")
-        gr.Markdown("Generate 3D human motion animations from text descriptions")
-        
-        with gr.Row():
-            with gr.Column():
-                text_input = gr.Textbox(
-                    label="Describe the motion you want to generate",
-                    placeholder="e.g., 'a person walks forward and waves'",
-                    lines=3
-                )
-                submit_btn = gr.Button("Generate Motion", variant="primary")
-                
-                gr.Examples(
-                    examples=[
-                        ["a person walks forward"],
-                        ["a person jumps in place"],
-                        ["someone performs a dance move"],
-                        ["a person sits down on a chair"],
-                        ["a person runs and then stops"],
-                    ],
-                    inputs=text_input,
-                    label="Try these examples"
-                )
-            
-            with gr.Column():
-                video_output = gr.Video(label="Generated Motion", elem_classes="video-fixed-height")
-        
-        submit_btn.click(
-            fn=generate_motion,
-            inputs=text_input,
-            outputs=video_output
-        )
-    
-    return demo
-
-
-if __name__ == '__main__':
-    # Configuration
-    CHECKPOINTS_DIR = './checkpoints'
-    DATASET_NAME = 't2m'  # or 'kit'
-    MODEL_NAME = 't2m_nlayer8_nhead6_ld384_ff1024_cdp0.1_rvq6ns'
-    RES_NAME = 'rvq_nq6_dc512_nc512_noshare_qdp0.2'
-    VQ_NAME = 'rvq_nq6_dc512_nc512_noshare_qdp0.2'
-
-    # Initialize generator
-    generator = MotionGenerator(
-        checkpoints_dir=CHECKPOINTS_DIR,
-        dataset_name=DATASET_NAME,
-        model_name=MODEL_NAME,
-        res_name=RES_NAME,
-        vq_name=VQ_NAME,
-        device='cuda'
-    )
-    
-    # Create and launch Gradio interface
-    demo = create_gradio_interface(generator)
-    demo.launch( server_name="0.0.0.0", server_port=7860)
+import os
+from os.path import join as pjoin
+import gradio as gr
+import torch
+import torch.nn.functional as F
+import numpy as np
+from torch.distributions.categorical import Categorical
+
+from models.mask_transformer.transformer import MaskTransformer, ResidualTransformer
+from models.vq.model import RVQVAE, LengthEstimator
+from utils.get_opt import get_opt
+from utils.fixseed import fixseed
+from visualization.joints2bvh import Joint2BVHConvertor
+from utils.motion_process import recover_from_ric
+from utils.plot_script import plot_3d_motion
+from utils.paramUtil import t2m_kinematic_chain
+
+clip_version = 'ViT-B/32'
+
+class MotionGenerator:
+    def __init__(self, checkpoints_dir, dataset_name, model_name, res_name, vq_name, device='cuda'):
+        self.device = torch.device(device if torch.cuda.is_available() else 'cpu')
+        self.dataset_name = dataset_name
+        self.dim_pose = 251 if dataset_name == 'kit' else 263
+        self.nb_joints = 21 if dataset_name == 'kit' else 22
+        
+        # Load models
+        print("Loading models...")
+        self.vq_model, self.vq_opt = self._load_vq_model(checkpoints_dir, dataset_name, vq_name)
+        self.t2m_transformer = self._load_trans_model(checkpoints_dir, dataset_name, model_name)
+        self.res_model = self._load_res_model(checkpoints_dir, dataset_name, res_name, self.vq_opt)
+        self.length_estimator = self._load_len_estimator(checkpoints_dir, dataset_name)
+        
+        # Set to eval mode
+        self.vq_model.eval()
+        self.t2m_transformer.eval()
+        self.res_model.eval()
+        self.length_estimator.eval()
+        
+        # Load normalization stats
+        meta_dir = pjoin(checkpoints_dir, dataset_name, vq_name, 'meta')
+        self.mean = np.load(pjoin(meta_dir, 'mean.npy'))
+        self.std = np.load(pjoin(meta_dir, 'std.npy'))
+        
+        self.kinematic_chain = t2m_kinematic_chain
+        self.converter = Joint2BVHConvertor()
+        
+        print("Models loaded successfully!")
+    
+    def _load_vq_model(self, checkpoints_dir, dataset_name, vq_name):
+        vq_opt_path = pjoin(checkpoints_dir, dataset_name, vq_name, 'opt.txt')
+        vq_opt = get_opt(vq_opt_path, device=self.device)
+        vq_opt.dim_pose = self.dim_pose
+        
+        vq_model = RVQVAE(vq_opt,
+                    vq_opt.dim_pose,
+                    vq_opt.nb_code,
+                    vq_opt.code_dim,
+                    vq_opt.output_emb_width,
+                    vq_opt.down_t,
+                    vq_opt.stride_t,
+                    vq_opt.width,
+                    vq_opt.depth,
+                    vq_opt.dilation_growth_rate,
+                    vq_opt.vq_act,
+                    vq_opt.vq_norm)
+        
+        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, vq_name, 'model', 'net_best_fid.tar'),
+                                map_location=self.device)
+        model_key = 'vq_model' if 'vq_model' in ckpt else 'net'
+        vq_model.load_state_dict(ckpt[model_key])
+        vq_model.to(self.device)
+        
+        return vq_model, vq_opt
+    
+    def _load_trans_model(self, checkpoints_dir, dataset_name, model_name):
+        model_opt_path = pjoin(checkpoints_dir, dataset_name, model_name, 'opt.txt')
+        model_opt = get_opt(model_opt_path, device=self.device)
+        
+        model_opt.num_tokens = self.vq_opt.nb_code
+        model_opt.num_quantizers = self.vq_opt.num_quantizers
+        model_opt.code_dim = self.vq_opt.code_dim
+        
+        # Set default values for missing attributes
+        if not hasattr(model_opt, 'latent_dim'):
+            model_opt.latent_dim = 384
+        if not hasattr(model_opt, 'ff_size'):
+            model_opt.ff_size = 1024
+        if not hasattr(model_opt, 'n_layers'):
+            model_opt.n_layers = 8
+        if not hasattr(model_opt, 'n_heads'):
+            model_opt.n_heads = 6
+        if not hasattr(model_opt, 'dropout'):
+            model_opt.dropout = 0.1
+        if not hasattr(model_opt, 'cond_drop_prob'):
+            model_opt.cond_drop_prob = 0.1
+        
+        t2m_transformer = MaskTransformer(code_dim=model_opt.code_dim,
+                                          cond_mode='text',
+                                          latent_dim=model_opt.latent_dim,
+                                          ff_size=model_opt.ff_size,
+                                          num_layers=model_opt.n_layers,
+                                          num_heads=model_opt.n_heads,
+                                          dropout=model_opt.dropout,
+                                          clip_dim=512,
+                                          cond_drop_prob=model_opt.cond_drop_prob,
+                                          clip_version=clip_version,
+                                          opt=model_opt)
+        
+        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, model_name, 'model', 'latest.tar'),
+                          map_location=self.device)
+        model_key = 't2m_transformer' if 't2m_transformer' in ckpt else 'trans'
+        t2m_transformer.load_state_dict(ckpt[model_key], strict=False)
+        t2m_transformer.to(self.device)
+        
+        return t2m_transformer
+    
+    def _load_res_model(self, checkpoints_dir, dataset_name, res_name, vq_opt):
+        res_opt_path = pjoin(checkpoints_dir, dataset_name, res_name, 'opt.txt')
+        res_opt = get_opt(res_opt_path, device=self.device)
+        
+        # The res_name appears to be the same as vq_name, so res_opt is actually vq_opt
+        # We need to use proper model architecture parameters
+        res_opt.num_quantizers = vq_opt.num_quantizers
+        res_opt.num_tokens = vq_opt.nb_code
+        
+        # Set architecture parameters for ResidualTransformer
+        # These should match the main transformer architecture
+        res_opt.latent_dim = 384  # Match with main transformer
+        res_opt.ff_size = 1024
+        res_opt.n_layers = 9  # Typically slightly more layers for residual
+        res_opt.n_heads = 6
+        res_opt.dropout = 0.1
+        res_opt.cond_drop_prob = 0.1
+        res_opt.share_weight = False
+        
+        print(f"ResidualTransformer config - latent_dim: {res_opt.latent_dim}, ff_size: {res_opt.ff_size}, nlayers: {res_opt.n_layers}, nheads: {res_opt.n_heads}, dropout: {res_opt.dropout}")
+        
+        res_transformer = ResidualTransformer(code_dim=vq_opt.code_dim,
+                                                cond_mode='text',
+                                                latent_dim=res_opt.latent_dim,
+                                                ff_size=res_opt.ff_size,
+                                                num_layers=res_opt.n_layers,
+                                                num_heads=res_opt.n_heads,
+                                                dropout=res_opt.dropout,
+                                                clip_dim=512,
+                                                shared_codebook=vq_opt.shared_codebook,
+                                                cond_drop_prob=res_opt.cond_drop_prob,
+                                                share_weight=res_opt.share_weight,
+                                                clip_version=clip_version,
+                                                opt=res_opt)
+        
+        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, res_name, 'model', 'net_best_fid.tar'),
+                          map_location=self.device)
+        
+        # Debug: check available keys
+        print(f"Available checkpoint keys: {ckpt.keys()}")
+        
+        # Try different possible keys for the model state dict
+        model_key = None
+        for key in ['res_transformer', 'trans', 'net', 'model', 'state_dict']:
+            if key in ckpt:
+                model_key = key
+                break
+        
+        if model_key:
+            print(f"Loading ResidualTransformer from key: {model_key}")
+            res_transformer.load_state_dict(ckpt[model_key], strict=False)
+        else:
+            print("Warning: Could not find model weights in checkpoint. Available keys:", list(ckpt.keys()))
+            # If this is actually a VQ model checkpoint, we might need to skip loading or handle differently
+            if 'vq_model' in ckpt or 'net' in ckpt:
+                print("This appears to be a VQ model checkpoint, not a ResidualTransformer checkpoint.")
+                print("Skipping weight loading - using randomly initialized ResidualTransformer.")
+        
+        res_transformer.to(self.device)
+        
+        return res_transformer
+    
+    def _load_len_estimator(self, checkpoints_dir, dataset_name):
+        model = LengthEstimator(512, 50)
+        ckpt = torch.load(pjoin(checkpoints_dir, dataset_name, 'length_estimator', 'model', 'finest.tar'),
+                          map_location=self.device)
+        model.load_state_dict(ckpt['estimator'])
+        model.to(self.device)
+        return model
+    
+    def inv_transform(self, data):
+        return data * self.std + self.mean
+    
+    @torch.no_grad()
+    def generate(self, text_prompt, motion_length=0, time_steps=18, cond_scale=4, 
+                 temperature=1, topkr=0.9, gumbel_sample=True, seed=42):
+        """
+        Generate motion from text prompt
+        
+        Args:
+            text_prompt: Text description of the motion
+            motion_length: Desired motion length (0 for auto-estimation)
+            time_steps: Number of denoising steps
+            cond_scale: Classifier-free guidance scale
+            temperature: Sampling temperature
+            topkr: Top-k filtering threshold
+            gumbel_sample: Whether to use Gumbel sampling
+            seed: Random seed
+        """
+        fixseed(seed)
+        
+        # Convert motion_length to int if needed
+        if isinstance(motion_length, float):
+            motion_length = int(motion_length)
+        
+        # Estimate length if not provided
+        if motion_length == 0:
+            text_embedding = self.t2m_transformer.encode_text([text_prompt])
+            pred_dis = self.length_estimator(text_embedding)
+            probs = F.softmax(pred_dis, dim=-1)
+            token_lens = Categorical(probs).sample()
+        else:
+            token_lens = torch.LongTensor([motion_length // 4]).to(self.device)
+        
+        m_length = token_lens * 4
+        
+        # Generate motion tokens
+        mids = self.t2m_transformer.generate([text_prompt], token_lens,
+                                            timesteps=int(time_steps),
+                                            cond_scale=float(cond_scale),
+                                            temperature=float(temperature),
+                                            topk_filter_thres=float(topkr),
+                                            gsample=gumbel_sample)
+        
+        # Refine with residual transformer
+        mids = self.res_model.generate(mids, [text_prompt], token_lens, 
+                                      temperature=1, cond_scale=5)
+        
+        # Decode to motion
+        pred_motions = self.vq_model.forward_decoder(mids)
+        pred_motions = pred_motions.detach().cpu().numpy()
+        
+        # Denormalize
+        data = self.inv_transform(pred_motions)
+        joint_data = data[0, :m_length[0]]
+        
+        # Recover 3D joints
+        joint = recover_from_ric(torch.from_numpy(joint_data).float(), self.nb_joints).numpy()
+        
+        return joint, int(m_length[0].item())
+
+
+def create_gradio_interface(generator, output_dir='./gradio_outputs'):
+    os.makedirs(output_dir, exist_ok=True)
+
+    def generate_motion(text_prompt, progress=gr.Progress()):
+        try:
+            import time
+            start_time = time.time()
+
+            print(f"\n{'='*70}")
+            print(f"[START] Generating motion for: '{text_prompt}'")
+            print(f"Device: {generator.device}")
+            print(f"{'='*70}")
+
+            # Use default parameters for simplicity
+            motion_length = 0  # Auto-estimate
+            time_steps = 18
+            cond_scale = 4.0
+            temperature = 1.0
+            topkr = 0.9
+            use_gumbel = True
+            seed = 42
+            use_ik = True
+
+            # Show warning about CPU
+            if str(generator.device) == 'cpu':
+                print("\n⚠️  WARNING: Using CPU - this will take 10-30 minutes!")
+                print("For faster inference, upgrade Space to GPU hardware.")
+
+            # Generate motion
+            progress(0.1, desc="[1/4] Generating motion tokens (10-20 mins on CPU)...")
+            print("[1/4] Generating motion tokens...")
+
+            joint, actual_length = generator.generate(
+                text_prompt,
+                motion_length,
+                time_steps,
+                cond_scale,
+                temperature,
+                topkr,
+                use_gumbel,
+                seed
+            )
+
+            elapsed = time.time() - start_time
+            print(f"✓ Generated {actual_length} frames in {elapsed:.1f}s")
+
+            # Save BVH and video
+            progress(0.6, desc="[2/4] Converting to BVH format...")
+            print("[2/4] Converting to BVH format...")
+
+            timestamp = str(np.random.randint(100000))
+            video_path = pjoin(output_dir, f'motion_{timestamp}.mp4')
+
+            # Convert to BVH with foot IK
+            _, joint_processed = generator.converter.convert(
+                joint, filename=None, iterations=100, foot_ik=True
+            )
+
+            print("✓ BVH conversion complete")
+
+            # Create video
+            progress(0.8, desc="[3/4] Rendering video...")
+            print("[3/4] Rendering video...")
+
+            plot_3d_motion(video_path, generator.kinematic_chain, joint_processed,
+                          title=text_prompt, fps=20)
+
+            print(f"✓ Video saved: {video_path}")
+
+            progress(1.0, desc="[4/4] Complete!")
+            total_time = time.time() - start_time
+            print(f"[4/4] Complete! Total time: {total_time:.1f}s")
+            print(f"{'='*70}\n")
+
+            return video_path
+
+        except Exception as e:
+            import traceback
+            error_msg = f"Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+            print("="*70)
+            print("ERROR during generation:")
+            print("="*70)
+            print(error_msg)
+            print("="*70)
+            return None
+    
+    # Create Gradio interface with Blocks for custom layout
+    with gr.Blocks(theme=gr.themes.Base(
+        primary_hue="blue",
+        secondary_hue="gray",
+    ).set(
+        body_background_fill="*neutral_950",
+        body_background_fill_dark="*neutral_950",
+        background_fill_primary="*neutral_900",
+        background_fill_primary_dark="*neutral_900",
+        background_fill_secondary="*neutral_800",
+        background_fill_secondary_dark="*neutral_800",
+        block_background_fill="*neutral_900",
+        block_background_fill_dark="*neutral_900",
+        input_background_fill="*neutral_800",
+        input_background_fill_dark="*neutral_800",
+        button_primary_background_fill="*primary_600",
+        button_primary_background_fill_dark="*primary_600",
+        button_primary_text_color="white",
+        button_primary_text_color_dark="white",
+        block_label_text_color="*neutral_200",
+        block_label_text_color_dark="*neutral_200",
+        body_text_color="*neutral_200",
+        body_text_color_dark="*neutral_200",
+        input_placeholder_color="*neutral_500",
+        input_placeholder_color_dark="*neutral_500",
+    ),
+    css="""
+        footer {display: none !important;}
+        .video-fixed-height {
+            height: 600px !important;
+        }
+        .video-fixed-height video {
+            max-height: 600px !important;
+            object-fit: contain !important;
+        }
+    """) as demo:
+        
+        gr.Markdown("# 🎭 Text-to-Motion Generator")
+        gr.Markdown("Generate 3D human motion animations from text descriptions")
+
+        # Show CPU warning if applicable
+        device_str = str(generator.device)
+        if 'cpu' in device_str:
+            gr.Markdown("""
+            ### ⚠️ Performance Notice
+            This Space is running on **CPU** (free tier). Generation takes **15-30 minutes** per prompt.
+            Please be patient! For faster results (~30 seconds), upgrade to GPU in Space Settings.
+            """)
+        else:
+            gr.Markdown(f"### ✅ Running on: {device_str.upper()}")
+        
+        with gr.Row():
+            with gr.Column():
+                text_input = gr.Textbox(
+                    label="Describe the motion you want to generate",
+                    placeholder="e.g., 'a person walks forward and waves'",
+                    lines=3
+                )
+                submit_btn = gr.Button("Generate Motion", variant="primary")
+                
+                gr.Examples(
+                    examples=[
+                        ["a person walks forward"],
+                        ["a person jumps in place"],
+                        ["someone performs a dance move"],
+                        ["a person sits down on a chair"],
+                        ["a person runs and then stops"],
+                    ],
+                    inputs=text_input,
+                    label="Try these examples"
+                )
+            
+            with gr.Column():
+                video_output = gr.Video(label="Generated Motion", elem_classes="video-fixed-height")
+        
+        submit_btn.click(
+            fn=generate_motion,
+            inputs=text_input,
+            outputs=video_output
+        )
+    
+    return demo
+
+
+if __name__ == '__main__':
+    # Configuration
+    CHECKPOINTS_DIR = './checkpoints'
+    DATASET_NAME = 't2m'  # or 'kit'
+    MODEL_NAME = 't2m_nlayer8_nhead6_ld384_ff1024_cdp0.1_rvq6ns'
+    RES_NAME = 'rvq_nq6_dc512_nc512_noshare_qdp0.2'
+    VQ_NAME = 'rvq_nq6_dc512_nc512_noshare_qdp0.2'
+
+    # Initialize generator
+    generator = MotionGenerator(
+        checkpoints_dir=CHECKPOINTS_DIR,
+        dataset_name=DATASET_NAME,
+        model_name=MODEL_NAME,
+        res_name=RES_NAME,
+        vq_name=VQ_NAME,
+        device='cuda'
+    )
+    
+    # Create and launch Gradio interface
+    demo = create_gradio_interface(generator)
+    demo.launch(server_name="0.0.0.0", server_port=7860)

debug_hf_space.py

@@ -0,0 +1,182 @@
+"""
+Debug Hugging Face Space - Check logs and diagnose issues
+"""
+import os
+import sys
+from huggingface_hub import HfApi
+import time
+
+# Configuration
+YOUR_USERNAME = "nocapdev"
+SPACE_NAME = "my-gradio-momask"
+TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+
+def main():
+    print("=" * 80)
+    print(" " * 25 + "HF Space Debugger")
+    print("=" * 80)
+
+    if not TOKEN:
+        print("\n❌ ERROR: HUGGINGFACE_TOKEN not set")
+        print("Set it with: $env:HUGGINGFACE_TOKEN = 'hf_your_token'")
+        print("\nAlternatively, check logs manually at:")
+        print(f"https://huggingface.co/spaces/{YOUR_USERNAME}/{SPACE_NAME}/logs")
+        return
+
+    api = HfApi(token=TOKEN)
+    repo_id = f"{YOUR_USERNAME}/{SPACE_NAME}"
+
+    print(f"\n📍 Space: {repo_id}")
+    print(f"🔗 URL: https://huggingface.co/spaces/{repo_id}")
+    print(f"📊 Logs: https://huggingface.co/spaces/{repo_id}/logs")
+
+    try:
+        # Get space runtime info
+        print("\n" + "─" * 80)
+        print("🔧 RUNTIME INFORMATION")
+        print("─" * 80)
+
+        runtime = api.get_space_runtime(repo_id=repo_id)
+
+        print(f"Status: {runtime.stage}")
+        print(f"Hardware: {runtime.hardware or 'CPU basic (free)'}")
+
+        # Try to get SDK info if available
+        try:
+            print(f"SDK: {runtime.sdk}")
+        except AttributeError:
+            print(f"SDK: gradio (inferred)")
+
+        try:
+            print(f"SDK Version: {runtime.sdk_version or 'N/A'}")
+        except AttributeError:
+            print(f"SDK Version: N/A")
+
+        # Analyze status
+        if runtime.stage == "RUNNING":
+            print("\n✅ Space is RUNNING")
+        elif runtime.stage == "BUILDING":
+            print("\n⏳ Space is BUILDING... (wait a few minutes)")
+        elif runtime.stage == "STOPPED":
+            print("\n⚠️  Space is STOPPED (may have crashed)")
+        elif runtime.stage == "SLEEPING":
+            print("\n😴 Space is SLEEPING (will wake on visit)")
+        else:
+            print(f"\n⚠️  Unexpected stage: {runtime.stage}")
+
+        # Hardware analysis
+        print("\n" + "─" * 80)
+        print("💻 HARDWARE ANALYSIS")
+        print("─" * 80)
+
+        hardware = str(runtime.hardware or 'cpu-basic').lower()
+
+        if 'cpu' in hardware or runtime.hardware is None:
+            print("⚠️  Using CPU (FREE tier)")
+            print("   • Generation time: 10-30 minutes per prompt")
+            print("   • This is NORMAL for free tier")
+            print("   • Recommendation: Upgrade to GPU or be patient")
+        elif 't4' in hardware:
+            print("✅ Using T4 GPU")
+            print("   • Generation time: 20-60 seconds per prompt")
+            print("   • Good performance")
+        elif 'a10' in hardware or 'a100' in hardware:
+            print("✅ Using High-end GPU")
+            print("   • Generation time: 10-30 seconds per prompt")
+            print("   • Excellent performance")
+
+        # Get space info
+        print("\n" + "─" * 80)
+        print("📦 SPACE FILES")
+        print("─" * 80)
+
+        try:
+            files = api.list_repo_files(repo_id=repo_id, repo_type="space")
+
+            # Check critical files
+            critical_files = ['app.py', 'requirements.txt', 'README.md']
+            for file in critical_files:
+                if file in files:
+                    print(f"✅ {file}")
+                else:
+                    print(f"❌ {file} - MISSING!")
+
+            # Check for checkpoints
+            checkpoint_files = [f for f in files if 'checkpoint' in f.lower() or f.endswith('.tar') or f.endswith('.pth')]
+
+            if checkpoint_files:
+                print(f"\n✅ Found {len(checkpoint_files)} checkpoint files")
+                print("   Sample files:")
+                for f in checkpoint_files[:5]:
+                    print(f"   • {f}")
+                if len(checkpoint_files) > 5:
+                    print(f"   ... and {len(checkpoint_files) - 5} more")
+            else:
+                print("\n⚠️  NO checkpoint files found!")
+                print("   • Models may not be uploaded")
+                print("   • App will fail to initialize")
+                print("   • Action: Upload checkpoints/ directory")
+
+        except Exception as e:
+            print(f"⚠️  Could not list files: {e}")
+
+        # Provide debugging steps
+        print("\n" + "=" * 80)
+        print("🔍 DEBUGGING STEPS")
+        print("=" * 80)
+
+        print("\n1. CHECK LOGS MANUALLY:")
+        print(f"   Visit: https://huggingface.co/spaces/{repo_id}/logs")
+        print("   Look for:")
+        print("   • 'Using device: cpu' or 'Using device: cuda'")
+        print("   • Any ERROR messages")
+        print("   • 'Model checkpoints not found'")
+        print("   • Traceback or exception messages")
+
+        print("\n2. COMMON ERROR PATTERNS:")
+        print("   • 'FileNotFoundError' → Models not uploaded")
+        print("   • 'CUDA out of memory' → Need more GPU RAM")
+        print("   • 'Killed' or 'SIGKILL' → Out of RAM")
+        print("   • Hangs at '[1/4] Generating...' → CPU is slow (wait 20 mins)")
+
+        print("\n3. QUICK TESTS:")
+        print("   • Visit the Space URL")
+        print("   • Try prompt: 'a person walks forward'")
+        print("   • Monitor Logs tab while it runs")
+
+        if 'cpu' in hardware or runtime.hardware is None:
+            print("\n⚠️  CPU PERFORMANCE WARNING:")
+            print("   Your Space is using CPU. Expected behavior:")
+            print("   • First load: 2-5 minutes (loading models)")
+            print("   • Each generation: 10-30 minutes")
+            print("   • This is NORMAL for CPU!")
+            print("   • Solutions:")
+            print("     - Wait patiently (free)")
+            print("     - Upgrade to T4 GPU (~$0.60/hour)")
+
+        print("\n4. IMMEDIATE ACTION:")
+        print("   Copy the ERROR message from Logs tab and share it")
+
+        print("\n" + "=" * 80)
+
+    except Exception as e:
+        print("\n" + "=" * 80)
+        print("❌ ERROR CHECKING SPACE")
+        print("=" * 80)
+        print(f"Error: {e}")
+        print("\nManual debugging required:")
+        print(f"1. Visit: https://huggingface.co/spaces/{repo_id}")
+        print(f"2. Click 'Logs' tab")
+        print(f"3. Copy the last 50 lines")
+        print(f"4. Share the error messages")
+        print("\n" + "=" * 80)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\nCancelled by user")
+    except Exception as e:
+        print(f"\n\nUnexpected error: {e}")
+        import traceback
+        traceback.print_exc()

get_logs.py

@@ -0,0 +1,85 @@
+"""
+Simple script to fetch and display HF Space logs
+"""
+import os
+from huggingface_hub import HfApi
+
+YOUR_USERNAME = "nocapdev"
+SPACE_NAME = "my-gradio-momask"
+TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+
+print("=" * 80)
+print(" " * 25 + "HF Space Log Viewer")
+print("=" * 80)
+
+if not TOKEN:
+    print("\n⚠️  HUGGINGFACE_TOKEN not set")
+    print("Manual access:")
+    print(f"Visit: https://huggingface.co/spaces/{YOUR_USERNAME}/{SPACE_NAME}/logs")
+else:
+    api = HfApi(token=TOKEN)
+    repo_id = f"{YOUR_USERNAME}/{SPACE_NAME}"
+
+    print(f"\n📍 Space: {repo_id}")
+    print(f"🔗 Logs: https://huggingface.co/spaces/{repo_id}/logs")
+
+    try:
+        print("\n" + "─" * 80)
+        print("🔧 SPACE STATUS")
+        print("─" * 80)
+
+        runtime = api.get_space_runtime(repo_id=repo_id)
+
+        print(f"\nStatus: {runtime.stage}")
+
+        hardware = str(runtime.hardware) if runtime.hardware else "CPU basic (free tier)"
+        print(f"Hardware: {hardware}")
+
+        if runtime.stage == "RUNNING":
+            print("✅ Space is RUNNING")
+        elif runtime.stage == "BUILDING":
+            print("⏳ Space is BUILDING")
+        elif runtime.stage == "STOPPED":
+            print("⚠️  Space STOPPED (may have crashed)")
+
+        # Hardware warning
+        if not runtime.hardware or 'cpu' in str(runtime.hardware).lower():
+            print("\n⚠️  PERFORMANCE WARNING:")
+            print("   Using CPU (free tier)")
+            print("   Expected generation time: 15-30 minutes per prompt")
+            print("   This is NORMAL for free tier!")
+
+        print("\n" + "─" * 80)
+        print("📋 WHAT TO CHECK IN LOGS")
+        print("─" * 80)
+        print("\n1. Visit the logs manually:")
+        print(f"   https://huggingface.co/spaces/{repo_id}/logs")
+        print("\n2. Look for these key lines:")
+        print("   • 'Using device: cpu' or 'Using device: cuda'")
+        print("   • 'Loading models...'")
+        print("   • 'Models loaded successfully!'")
+        print("   • Any lines with 'ERROR' or 'Exception'")
+        print("   • 'Model checkpoints not found'")
+        print("   • '[1/4] Generating motion tokens...'")
+        print("\n3. Common issues to look for:")
+        print("   • FileNotFoundError → Models not uploaded")
+        print("   • Killed/SIGKILL → Out of memory")
+        print("   • Stuck at [1/4] → CPU is slow (wait 20 mins)")
+
+        print("\n" + "─" * 80)
+        print("💡 NEXT STEPS")
+        print("─" * 80)
+        print("\n1. Click the link above to view logs")
+        print("2. Copy the LAST 50 LINES from the logs")
+        print("3. Share them here so I can diagnose the issue")
+        print("\nSpecifically look for:")
+        print("  • Any ERROR messages")
+        print("  • Any Exception or Traceback")
+        print("  • What happened after you submitted your prompt")
+
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        print(f"\nManual check required:")
+        print(f"Visit: https://huggingface.co/spaces/{repo_id}/logs")
+
+print("\n" + "=" * 80)

simple_check.py

@@ -0,0 +1,119 @@
+"""
+Simple HF Space checker without Unicode issues
+"""
+import os
+import sys
+
+# Fix Windows encoding
+if sys.platform == 'win32':
+    import io
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+from huggingface_hub import HfApi
+
+YOUR_USERNAME = "nocapdev"
+SPACE_NAME = "my-gradio-momask"
+TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+
+print("=" * 80)
+print("HF SPACE STATUS CHECK")
+print("=" * 80)
+
+repo_id = f"{YOUR_USERNAME}/{SPACE_NAME}"
+
+if not TOKEN:
+    print("\nWARNING: HUGGINGFACE_TOKEN not set")
+    print(f"\nTo check your Space manually:")
+    print(f"1. Visit: https://huggingface.co/spaces/{repo_id}")
+    print(f"2. Click 'Logs' tab")
+    print(f"3. Copy the last 50 lines")
+    print(f"4. Look for ERROR messages")
+    sys.exit(0)
+
+try:
+    api = HfApi(token=TOKEN)
+
+    print(f"\nSpace: {repo_id}")
+    print(f"URL: https://huggingface.co/spaces/{repo_id}")
+    print(f"Logs: https://huggingface.co/spaces/{repo_id}/logs")
+
+    print("\n" + "-" * 80)
+    print("RUNTIME INFO")
+    print("-" * 80)
+
+    runtime = api.get_space_runtime(repo_id=repo_id)
+
+    print(f"\nStatus: {runtime.stage}")
+
+    hardware = str(runtime.hardware) if runtime.hardware else "cpu-basic"
+    print(f"Hardware: {hardware}")
+
+    # Status analysis
+    print("\n" + "-" * 80)
+    print("ANALYSIS")
+    print("-" * 80)
+
+    if runtime.stage == "RUNNING":
+        print("\n[OK] Space is RUNNING")
+    elif runtime.stage == "BUILDING":
+        print("\n[WAIT] Space is BUILDING (wait 2-3 minutes)")
+    elif runtime.stage == "STOPPED":
+        print("\n[ERROR] Space STOPPED - may have crashed")
+        print("Check logs for errors!")
+    else:
+        print(f"\n[WARNING] Unexpected status: {runtime.stage}")
+
+    # Hardware check
+    if 'cpu' in hardware.lower() or hardware == "cpu-basic":
+        print("\n[SLOW] Using CPU (free tier)")
+        print("  - Generation time: 15-30 minutes per prompt")
+        print("  - This is NORMAL for free tier")
+        print("  - Solution: Wait OR upgrade to GPU")
+    else:
+        print(f"\n[FAST] Using GPU: {hardware}")
+        print("  - Generation time: 30-60 seconds per prompt")
+
+    # Check files
+    print("\n" + "-" * 80)
+    print("FILES CHECK")
+    print("-" * 80)
+
+    files = api.list_repo_files(repo_id=repo_id, repo_type="space")
+
+    # Critical files
+    for f in ['app.py', 'requirements.txt', 'README.md']:
+        if f in files:
+            print(f"[OK] {f}")
+        else:
+            print(f"[MISSING] {f}")
+
+    # Checkpoints
+    checkpoint_files = [f for f in files if 'checkpoint' in f.lower() or f.endswith('.tar')]
+
+    if checkpoint_files:
+        print(f"\n[OK] Found {len(checkpoint_files)} checkpoint files")
+    else:
+        print("\n[WARNING] No checkpoint files found!")
+        print("  Models may not be uploaded")
+        print("  App will fail to load")
+
+    print("\n" + "=" * 80)
+    print("NEXT STEPS")
+    print("=" * 80)
+    print(f"\n1. View logs at: https://huggingface.co/spaces/{repo_id}/logs")
+    print("\n2. Look for:")
+    print("   - 'Using device: cpu' or 'cuda'")
+    print("   - 'Loading models...'")
+    print("   - Any ERROR messages")
+    print("   - 'Model checkpoints not found'")
+    print("\n3. Copy the last 50 lines from logs")
+    print("   Especially any lines with ERROR or Exception")
+    print("\n4. Share those lines to get exact solution")
+
+    print("\n" + "=" * 80)
+
+except Exception as e:
+    print(f"\nERROR: {e}")
+    print(f"\nManual check:")
+    print(f"Visit: https://huggingface.co/spaces/{repo_id}/logs")
+    print("Copy the last 50 lines and share them")

test_local.py

@@ -0,0 +1,127 @@
+"""
+Test your setup locally before deploying to HF
+This helps identify issues without waiting for HF Space builds
+"""
+import os
+import sys
+import torch
+
+print("=" * 80)
+print(" " * 25 + "Local Setup Test")
+print("=" * 80)
+
+# Test 1: Python version
+print("\n[1/7] Python Version")
+print(f"✓ Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}")
+
+# Test 2: PyTorch
+print("\n[2/7] PyTorch")
+try:
+    print(f"✓ PyTorch version: {torch.__version__}")
+    print(f"✓ CUDA available: {torch.cuda.is_available()}")
+    if torch.cuda.is_available():
+        print(f"✓ CUDA version: {torch.version.cuda}")
+        print(f"✓ GPU: {torch.cuda.get_device_name(0)}")
+    else:
+        print("⚠️  No GPU detected (will use CPU)")
+except Exception as e:
+    print(f"❌ Error: {e}")
+
+# Test 3: Critical imports
+print("\n[3/7] Critical Dependencies")
+deps = {
+    'gradio': 'Gradio',
+    'numpy': 'NumPy',
+    'scipy': 'SciPy',
+    'matplotlib': 'Matplotlib',
+    'trimesh': 'Trimesh',
+    'einops': 'Einops',
+    'clip': 'OpenAI CLIP'
+}
+
+for module, name in deps.items():
+    try:
+        __import__(module)
+        print(f"✓ {name}")
+    except ImportError as e:
+        print(f"❌ {name} - NOT INSTALLED")
+
+# Test 4: Model checkpoints
+print("\n[4/7] Model Checkpoints")
+checkpoints_dir = './checkpoints'
+dataset_name = 't2m'
+
+if os.path.exists(checkpoints_dir):
+    print(f"✓ Checkpoints directory exists: {checkpoints_dir}")
+
+    # Check for specific model directories
+    models_to_check = [
+        f'{checkpoints_dir}/{dataset_name}/t2m_nlayer8_nhead6_ld384_ff1024_cdp0.1_rvq6ns',
+        f'{checkpoints_dir}/{dataset_name}/rvq_nq6_dc512_nc512_noshare_qdp0.2',
+        f'{checkpoints_dir}/{dataset_name}/length_estimator',
+    ]
+
+    for model_path in models_to_check:
+        if os.path.exists(model_path):
+            # Count files
+            files = []
+            for root, dirs, filenames in os.walk(model_path):
+                files.extend(filenames)
+            print(f"✓ {os.path.basename(model_path)} ({len(files)} files)")
+        else:
+            print(f"❌ {os.path.basename(model_path)} - NOT FOUND")
+else:
+    print(f"❌ Checkpoints directory NOT FOUND: {checkpoints_dir}")
+    print("   Models must be present for the app to work!")
+
+# Test 5: Try loading app.py
+print("\n[5/7] App.py Syntax")
+try:
+    with open('app.py', 'r', encoding='utf-8') as f:
+        compile(f.read(), 'app.py', 'exec')
+    print("✓ app.py syntax is valid")
+except FileNotFoundError:
+    print("❌ app.py not found")
+except SyntaxError as e:
+    print(f"❌ Syntax error: {e}")
+
+# Test 6: Required files
+print("\n[6/7] Required Files")
+required = ['app.py', 'requirements.txt', 'README.md']
+for file in required:
+    if os.path.exists(file):
+        size = os.path.getsize(file)
+        print(f"✓ {file} ({size} bytes)")
+    else:
+        print(f"❌ {file} - NOT FOUND")
+
+# Test 7: Disk space for outputs
+print("\n[7/7] Output Directory")
+output_dir = './gradio_outputs'
+try:
+    os.makedirs(output_dir, exist_ok=True)
+    print(f"✓ Output directory ready: {output_dir}")
+except Exception as e:
+    print(f"❌ Error creating output directory: {e}")
+
+# Summary
+print("\n" + "=" * 80)
+print("SUMMARY")
+print("=" * 80)
+
+# Check if ready
+if os.path.exists(checkpoints_dir) and os.path.exists('app.py'):
+    print("\n✅ Basic setup looks good!")
+    print("\nNext steps:")
+    print("1. Test locally: python app.py")
+    print("2. Visit http://localhost:7860 in browser")
+    print("3. Try a prompt and check for errors")
+    print("4. If it works locally, redeploy to HF")
+else:
+    print("\n⚠️  Setup incomplete!")
+    if not os.path.exists(checkpoints_dir):
+        print("\n❌ Missing: Model checkpoints")
+        print("   • Download models to ./checkpoints/")
+        print("   • Or configure model download in app.py")
+
+print("\n" + "=" * 80)