Add weight download on startup and clean up documentation

- Add download_weights_if_needed() function to app.py
- Download weights from HF model repo at startup if USE_REAL_MODEL=true
- Remove all extra MD files (DEPLOYMENT, HF_MODEL_SETUP, etc.)
- Keep only README.md

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

DEPLOYMENT.md

@@ -1,184 +0,0 @@
-# FoundationPose Hugging Face Space Deployment Guide
-
-This directory contains the code for deploying FoundationPose on Hugging Face Spaces with ZeroGPU support.
-
-## Current Status
-
-- ✅ Gradio app structure created
-- ✅ API endpoints defined (/initialize, /estimate)
-- ✅ ZeroGPU decorators added (@spaces.GPU)
-- ✅ Client library for API calls created
-- ⚠️ FoundationPose model integration incomplete (placeholder code)
-
-## Next Steps
-
-### 1. Complete FoundationPose Integration
-
-The current `app.py` has placeholder code marked with `# TODO` comments. You need to:
-
-1. **Install FoundationPose in the Space**:
-   - Add FoundationPose installation to requirements.txt or use a custom Dockerfile
-   - Download pre-trained weights (need to be included in the Space or downloaded at startup)
-
-2. **Implement model initialization** (line ~40 in app.py):
-   ```python
-   # Replace the TODO with actual FoundationPose initialization
-   from FoundationPose import FoundationPoseEstimator
-   self.model = FoundationPoseEstimator(device=self.device)
-   ```
-
-3. **Implement object registration** (line ~70):
-   ```python
-   # Replace the TODO with actual registration
-   self.model.register_object(object_id, reference_images, camera_intrinsics)
-   ```
-
-4. **Implement pose estimation** (line ~120):
-   ```python
-   # Replace the TODO with actual inference
-   result = self.model.estimate_pose(object_id, query_image, camera_intrinsics)
-   ```
-
-### 2. Handle Model Weights
-
-FoundationPose requires pre-trained weights. Options:
-
-**Option A: Git LFS (Recommended)**
-```bash
-cd foundationpose
-git lfs install
-mkdir weights
-# Download weights from FoundationPose repo
-wget https://... -O weights/model.pth
-git lfs track "weights/*.pth"
-git add weights/model.pth .gitattributes
-git commit -m "Add model weights"
-```
-
-**Option B: Download at Runtime**
-Add to `app.py`:
-```python
-def download_weights():
-    from huggingface_hub import hf_hub_download
-    weights_path = hf_hub_download(
-        repo_id="NVlabs/FoundationPose",
-        filename="model.pth"
-    )
-    return weights_path
-```
-
-### 3. Test Locally
-
-Before deploying, test the Space locally:
-
-```bash
-cd foundationpose
-pip install -r requirements.txt
-python app.py
-```
-
-This will start a local Gradio server at http://localhost:7860
-
-### 4. Deploy to Hugging Face
-
-```bash
-cd foundationpose
-git add .
-git commit -m "Add FoundationPose inference implementation"
-git push
-```
-
-The Space will automatically rebuild and deploy.
-
-### 5. Monitor GPU Usage
-
-After deployment:
-1. Check the Space logs for GPU allocation messages
-2. Monitor inference times (cold start vs warm)
-3. Adjust `@spaces.GPU(duration=X)` parameters if needed
-
-### 6. Integrate with Training Pipeline
-
-Once the Space is working, update the training code:
-
-**In training/nova_sim_trainer/perception/foundation_pose_wrapper.py**:
-```python
-from foundationpose.client import FoundationPoseClient
-
-class FoundationPoseWrapper(PoseEstimator):
-    def __init__(self, api_url: str, ...):
-        self.client = FoundationPoseClient(api_url)
-        # Initialize with reference images
-        ref_images = load_reference_images(reference_dir)
-        self.client.initialize(object_id, ref_images)
-
-    def estimate_poses(self, frame, camera_intrinsics, scene_objects):
-        poses = self.client.estimate_pose(self.object_id, frame, camera_intrinsics)
-        return [DetectedPose(**pose) for pose in poses]
-```
-
-**In training/observations.yaml**:
-```yaml
-perception:
-  enabled: true
-  model: foundation_pose
-  api_url: https://gpue-foundationpose.hf.space
-  tracked_objects:
-    - object_id: target_cube
-      reference_images_dir: ./perception/reference/target_cube
-```
-
-## Performance Considerations
-
-### ZeroGPU Latency
-- **Cold start**: 15-30 seconds (GPU allocation + model loading)
-- **Warm inference**: 0.5-2 seconds per query
-- **GPU duration**: Tune the `duration` parameter in `@spaces.GPU` decorators
-
-### Recommended Usage
-- ✅ **Batch processing**: Process multiple frames in one GPU allocation
-- ✅ **Validation**: Check perception quality on recorded episodes
-- ✅ **Demos**: Show 6D pose estimation capabilities
-- ⚠️ **Real-time training**: Too slow for 30 Hz control loop - use dummy estimator instead
-
-### Optimization Tips
-1. **Batch multiple queries** to amortize cold start time
-2. **Keep GPU warm** by sending periodic keep-alive requests
-3. **Use lower resolution** if inference is too slow
-4. **Cache results** for static scenes
-
-## Troubleshooting
-
-### Space won't start
-- Check Space logs for errors
-- Verify all dependencies in requirements.txt
-- Check Python version compatibility (3.12)
-
-### GPU timeout
-- Increase `duration` in `@spaces.GPU(duration=X)`
-- Optimize model inference code
-- Reduce image resolution
-
-### Out of memory
-- Reduce batch size
-- Use smaller model variant
-- Request more GPU memory in Space settings
-
-## Alternative: Docker Deployment
-
-If ZeroGPU is too restrictive, consider running locally with Docker:
-
-```bash
-cd foundationpose
-docker build -t foundationpose .
-docker run -p 7860:7860 --gpus all foundationpose
-```
-
-Then set `api_url: http://localhost:7860` in observations.yaml.
-
-## References
-
-- [FoundationPose GitHub](https://github.com/NVlabs/FoundationPose)
-- [Hugging Face Spaces](https://huggingface.co/docs/hub/spaces)
-- [ZeroGPU Documentation](https://huggingface.co/docs/hub/spaces-gpus-zerogpu)
-- [Gradio Documentation](https://www.gradio.app/docs)

HF_MODEL_SETUP.md

@@ -1,163 +0,0 @@
-# Quick Guide: Setting Up Model Weights on Hugging Face
-
-**TL;DR:** Host your FoundationPose weights in a HF model repository instead of your Space. It's easier, faster, and better.
-
-## Why This Way is Better
-
-| Method | Pros | Cons |
-|--------|------|------|
-| **HF Model Repo** ✅ | Fast CDN downloads, version control, share across Spaces, no git-lfs needed | Initial setup required |
-| Git-LFS in Space | All-in-one repo | Slow, complex, Space bloat, hard to share |
-| Manual upload to Space files | Simple | Not version controlled, no programmatic access |
-
-## 5-Minute Setup
-
-### 1. Download Weights (One-Time)
-
-```bash
-# Download from Google Drive:
-# https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da
-
-# You need:
-# - 2023-10-28-18-33-37/ (~900MB)
-# - 2024-01-11-20-02-45/ (~900MB)
-```
-
-### 2. Create Model Repo
-
-```bash
-pip install huggingface_hub
-huggingface-cli login
-huggingface-cli repo create foundationpose-weights --type model
-```
-
-Or create at: https://huggingface.co/new (select "Model")
-
-### 3. Upload Weights
-
-```bash
-cd /path/to/your/downloaded/weights
-
-huggingface-cli upload YOUR_USERNAME/foundationpose-weights \
-  ./2023-10-28-18-33-37 \
-  2023-10-28-18-33-37
-
-huggingface-cli upload YOUR_USERNAME/foundationpose-weights \
-  ./2024-01-11-20-02-45 \
-  2024-01-11-20-02-45
-```
-
-### 4. Configure Your Space
-
-Add to your Space's environment variables (Settings → Variables and secrets):
-
-```
-FOUNDATIONPOSE_MODEL_REPO=YOUR_USERNAME/foundationpose-weights
-USE_HF_WEIGHTS=true
-USE_REAL_MODEL=true
-```
-
-### 5. Deploy
-
-```bash
-cd foundationpose
-git push origin main
-```
-
-Your Space will automatically download weights on first run!
-
-## Verify It Works
-
-Check your Space logs at:
-`https://huggingface.co/spaces/YOUR_USERNAME/foundationpose/logs`
-
-Look for:
-```
-Downloading from Hugging Face Model Repository
-Repository: YOUR_USERNAME/foundationpose-weights
-✓ Download complete!
-```
-
-## Example Model Repo Structure
-
-Your model repo should look like:
-
-```
-YOUR_USERNAME/foundationpose-weights/
-├── README.md
-├── 2023-10-28-18-33-37/
-│   ├── model_0000000.pth
-│   ├── config.json
-│   └── ...
-└── 2024-01-11-20-02-45/
-    ├── model_0000000.pth
-    ├── config.json
-    └── ...
-```
-
-## Use in Other Projects
-
-Anyone can now use your weights:
-
-```python
-from huggingface_hub import snapshot_download
-
-# Download weights
-snapshot_download(
-    repo_id="YOUR_USERNAME/foundationpose-weights",
-    local_dir="./weights"
-)
-```
-
-## Make It Public or Private?
-
-**Public (Recommended):**
-- ✅ Anyone can use (including your Space)
-- ✅ No token needed
-- ✅ Community can benefit
-
-**Private:**
-- ✅ Control access
-- ❌ Need HF token in Space secrets
-- ❌ More complex setup
-
-For private repos, add `HF_TOKEN` to Space secrets.
-
-## Common Issues
-
-**"Repository not found"**
-→ Check name matches: `YOUR_USERNAME/foundationpose-weights`
-
-**"Access denied"**
-→ Make repo public or add HF_TOKEN secret
-
-**"Download slow"**
-→ First download is cached, subsequent runs are instant
-
-**"Out of space"**
-→ Free tier: ~50GB. Upgrade or use smaller models.
-
-## Complete Example
-
-```bash
-# Assuming weights downloaded to ~/Downloads/foundationpose-weights/
-
-# 1. Login
-huggingface-cli login
-
-# 2. Create repo
-huggingface-cli repo create foundationpose-weights --type model
-
-# 3. Upload
-cd ~/Downloads/foundationpose-weights
-huggingface-cli upload gpue/foundationpose-weights . .
-
-# 4. Done! Configure your Space:
-# FOUNDATIONPOSE_MODEL_REPO=gpue/foundationpose-weights
-# USE_HF_WEIGHTS=true
-# USE_REAL_MODEL=true
-```
-
----
-
-**Full details:** See [UPLOAD_WEIGHTS.md](UPLOAD_WEIGHTS.md) for comprehensive guide.

PRIVATE_REPO_SETUP.md

@@ -1,211 +0,0 @@
-# Private Model Repository Setup
-
-Your model repository `gpue/foundationpose-weights` is currently **PRIVATE** 🔒
-
-This document explains your options for using it with your Space.
-
----
-
-## Quick Answer
-
-**Yes, your Space needs a token** if the model repo stays private.
-
-**No token needed** if you make the repo public.
-
----
-
-## Option 1: Make Repository Public (Easiest) ✅
-
-### Why Choose This?
-- ✅ No token management
-- ✅ Simpler Space setup
-- ✅ Anyone can use your weights
-- ✅ No secrets to manage
-- ✅ Faster downloads (no auth overhead)
-
-### How to Make Public
-
-**Via CLI:**
-```bash
-/Users/georgpuschel/repos/robot-ml/training/.venv/bin/huggingface-cli repo update \
-  gpue/foundationpose-weights \
-  --visibility public \
-  --repo-type model
-```
-
-**Via Web:**
-1. Go to https://huggingface.co/gpue/foundationpose-weights/settings
-2. Under "Change repository visibility"
-3. Select "Public"
-4. Click "Update repository"
-
-**Then:**
-- Just deploy your Space - no additional setup needed!
-- Weights will download automatically
-
----
-
-## Option 2: Keep Private + Add Token 🔒
-
-### Why Choose This?
-- 🔒 Control access to weights
-- 🔒 Keep it between your Spaces
-- 🔒 Track who downloads
-
-### Setup Steps
-
-#### 1. Create HF Token
-
-Go to https://huggingface.co/settings/tokens and create a new token:
-
-- **Name:** `foundationpose-space` (or any name you want)
-- **Type:** `Read` (not Write)
-- **Permissions:**
-  - ✅ Read access to repos
-
-Copy the token (starts with `hf_...`)
-
-#### 2. Add Token to Space
-
-Go to your Space settings:
-https://huggingface.co/spaces/gpue/foundationpose/settings
-
-Scroll to **"Repository secrets"** and add:
-
-| Name | Value |
-|------|-------|
-| `HF_TOKEN` | `hf_xxxxxxxxxxxxx` (your token) |
-
-#### 3. Verify
-
-The code already supports token authentication:
-- `download_weights.py` will automatically use `HF_TOKEN` if available
-- No code changes needed!
-
-#### 4. Test
-
-Deploy your Space and check the logs:
-```
-🔒 Using HF_TOKEN for authentication (private repository)
-Downloading model weights...
-✓ Download complete!
-```
-
----
-
-## Current Status
-
-✅ **Model repo uploaded:** 258MB (2 weight files + configs + README)
-✅ **Token support added:** Code updated to use `HF_TOKEN` env var
-✅ **Dockerfile configured:** Points to your model repo by default
-❌ **Repository visibility:** Currently PRIVATE
-
----
-
-## Recommendation
-
-For a public inference Space like this, I recommend **making the model repo public**:
-
-**Pros:**
-- Simpler setup
-- No token management
-- Aligns with open-source spirit
-- Easier for others to use
-
-**Cons:**
-- Anyone can download the weights (but they're from official FoundationPose anyway)
-
-The FoundationPose weights are already public on Google Drive, so there's no confidentiality concern.
-
----
-
-## Testing
-
-### Verify Current Access
-
-```bash
-cd /Users/georgpuschel/repos/robot-ml/foundationpose
-
-# Test without token (will fail if private)
-unset HF_TOKEN
-/Users/georgpuschel/repos/robot-ml/training/.venv/bin/python verify_weights.py
-
-# Test with token (will work if token valid)
-export HF_TOKEN="hf_your_token_here"
-/Users/georgpuschel/repos/robot-ml/training/.venv/bin/python verify_weights.py
-```
-
-### After Making Public
-
-```bash
-# Should work without token
-/Users/georgpuschel/repos/robot-ml/training/.venv/bin/python verify_weights.py
-```
-
----
-
-## What I've Done
-
-1. ✅ Uploaded weights to `gpue/foundationpose-weights` (258MB)
-2. ✅ Added README.md to model repo with citation and usage
-3. ✅ Updated `download_weights.py` to support `HF_TOKEN`
-4. ✅ Updated Dockerfile to point to your model repo
-5. ✅ Created `verify_weights.py` to test access
-6. ✅ Improved error messages for auth failures
-
----
-
-## Next Steps (Choose One)
-
-### If Making Public:
-```bash
-# 1. Make repo public
-huggingface-cli repo update gpue/foundationpose-weights --visibility public --repo-type model
-
-# 2. Deploy Space
-cd /Users/georgpuschel/repos/robot-ml/foundationpose
-git add .
-git commit -m "Configure for model repo download"
-git push origin main
-
-# 3. Done! No token needed.
-```
-
-### If Keeping Private:
-```bash
-# 1. Get token from: https://huggingface.co/settings/tokens
-
-# 2. Add HF_TOKEN to Space secrets:
-#    https://huggingface.co/spaces/gpue/foundationpose/settings
-
-# 3. Deploy Space
-cd /Users/georgpuschel/repos/robot-ml/foundationpose
-git add .
-git commit -m "Configure for model repo download"
-git push origin main
-
-# 4. Space will authenticate with token automatically
-```
-
----
-
-## FAQ
-
-**Q: What if I forget to add the token?**
-A: Space will run in placeholder mode (empty results but API works).
-
-**Q: Can I change visibility later?**
-A: Yes! You can switch between public/private anytime.
-
-**Q: Does the token expire?**
-A: Tokens can expire if you set an expiration date. Use "No expiration" for Spaces.
-
-**Q: What if someone steals my token?**
-A: They can only READ your model repos. Revoke and create a new token if compromised.
-
-**Q: Can I use the same token for multiple Spaces?**
-A: Yes! Same token works across all your Spaces.
-
----
-
-**Recommendation:** Make the repo public for simplicity. The weights are already public via Google Drive anyway.

QUICKSTART.md

@@ -1,270 +0,0 @@
-# FoundationPose Quick Start Guide
-
-## Overview
-
-This Hugging Face Space provides two modes:
-
-1. **Placeholder Mode** (default) - Returns empty results, useful for testing the API without GPU requirements
-2. **Real Mode** - Uses actual FoundationPose model for 6D pose estimation (requires GPU and model weights)
-
-## Testing Locally (Placeholder Mode)
-
-The easiest way to test the API structure:
-
-```bash
-cd foundationpose
-pip install -r requirements.txt
-python app.py
-```
-
-Visit http://localhost:7860 to see the UI.
-
-## Deploying to Hugging Face Spaces
-
-### Option 1: Placeholder Mode (No Setup Required)
-
-Just push to your Space:
-
-```bash
-cd foundationpose
-git add .
-git commit -m "Deploy FoundationPose Space"
-git push
-```
-
-The Space will run in placeholder mode by default. This is useful for:
-- Testing the API structure
-- Developing client integrations
-- Demos without GPU costs
-
-### Option 2: Real FoundationPose (Requires Setup)
-
-**Step 1: Clone FoundationPose Repository**
-
-```bash
-# Inside your local foundationpose directory
-git clone https://github.com/NVlabs/FoundationPose.git
-```
-
-**Step 2: Download Model Weights**
-
-Download weights from the official Google Drive:
-https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da
-
-Extract to:
-```
-foundationpose/weights/
-  ├── 2023-10-28-18-33-37/  (refiner weights)
-  └── 2024-01-11-20-02-45/  (scorer weights)
-```
-
-**Step 3: Add Weights to Git LFS**
-
-```bash
-git lfs install
-git lfs track "weights/**/*.pth"
-git lfs track "weights/**/*.ckpt"
-git add .gitattributes
-git add weights/
-git commit -m "Add model weights"
-```
-
-**Step 4: Enable Real Mode**
-
-Add to your Space settings (or use .env file locally):
-```
-USE_REAL_MODEL=true
-```
-
-**Step 5: Push to HF**
-
-```bash
-git push
-```
-
-## Using the API
-
-### Python Client
-
-```python
-from foundationpose.client import FoundationPoseClient
-import cv2
-import numpy as np
-
-# Initialize client
-client = FoundationPoseClient("https://gpue-foundationpose.hf.space")
-
-# Load reference images
-ref_images = []
-for i in range(1, 16):
-    img = cv2.imread(f"reference/image_{i:03d}.jpg")
-    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    ref_images.append(img)
-
-# Register object
-client.initialize("target_cube", ref_images)
-
-# Estimate pose
-query_img = cv2.imread("query.jpg")
-query_img = cv2.cvtColor(query_img, cv2.COLOR_BGR2RGB)
-
-poses = client.estimate_pose("target_cube", query_img)
-print(f"Detected {len(poses)} poses")
-for pose in poses:
-    print(f"Position: {pose['position']}")
-    print(f"Orientation: {pose['orientation']}")
-    print(f"Confidence: {pose['confidence']}")
-```
-
-### Direct HTTP API
-
-```bash
-# Initialize
-curl -X POST https://gpue-foundationpose.hf.space/api/initialize \
-  -H "Content-Type: application/json" \
-  -d '{
-    "object_id": "target_cube",
-    "reference_images_b64": ["'$(base64 -w 0 ref1.jpg)'", "'$(base64 -w 0 ref2.jpg)'"],
-    "camera_intrinsics": "{\"fx\": 500, \"fy\": 500, \"cx\": 320, \"cy\": 240}"
-  }'
-
-# Estimate
-curl -X POST https://gpue-foundationpose.hf.space/api/estimate \
-  -H "Content-Type: application/json" \
-  -d '{
-    "object_id": "target_cube",
-    "query_image_b64": "'$(base64 -w 0 query.jpg)'"
-  }'
-```
-
-## Integration with robot-ml Training
-
-Update `/training/nova_sim_trainer/perception/foundation_pose_wrapper.py`:
-
-```python
-from foundationpose.client import FoundationPoseClient
-
-class FoundationPoseWrapper(PoseEstimator):
-    def __init__(self, api_url: str, tracked_objects: List[Dict], **kwargs):
-        super().__init__()
-        self.client = FoundationPoseClient(api_url)
-
-        # Initialize each tracked object
-        for obj_config in tracked_objects:
-            object_id = obj_config["object_id"]
-            ref_dir = Path(obj_config["reference_images_dir"])
-
-            # Load reference images
-            ref_images = []
-            for img_path in sorted(ref_dir.glob("*.jpg")):
-                img = cv2.imread(str(img_path))
-                img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                ref_images.append(img)
-
-            # Register object
-            self.client.initialize(object_id, ref_images)
-            logger.info(f"Registered {object_id} with {len(ref_images)} images")
-
-    def estimate_poses(self, frame, camera_intrinsics, scene_objects):
-        # Call API for pose estimation
-        poses = self.client.estimate_pose(
-            self.tracked_objects[0]["object_id"],  # For now, single object
-            frame,
-            camera_intrinsics
-        )
-
-        # Convert to DetectedPose format
-        return [DetectedPose(**pose) for pose in poses]
-```
-
-Update `observations.yaml`:
-
-```yaml
-perception:
-  enabled: true
-  model: foundation_pose
-  api_url: https://gpue-foundationpose.hf.space
-  tracked_objects:
-    - object_id: target_cube
-      reference_images_dir: ./perception/reference/target_cube
-```
-
-## Performance Tips
-
-### Cold Start Latency
-- First request takes 15-30s (GPU allocation + model loading)
-- Subsequent requests: 0.5-2s
-
-### Keeping GPU Warm
-Send periodic keep-alive requests:
-```python
-import time
-import threading
-
-def keep_warm():
-    while True:
-        try:
-            client.estimate_pose("target_cube", dummy_image)
-        except:
-            pass
-        time.sleep(60)  # Every minute
-
-threading.Thread(target=keep_warm, daemon=True).start()
-```
-
-### Batch Processing
-For recorded episodes, process all frames in one session:
-```python
-# Initialize once
-client.initialize("target_cube", ref_images)
-
-# Process all frames
-poses_list = []
-for frame in frames:
-    poses = client.estimate_pose("target_cube", frame)
-    poses_list.append(poses)
-```
-
-## Troubleshooting
-
-### Space shows "Placeholder mode"
-- Set `USE_REAL_MODEL=true` in Space secrets
-- Verify weights are uploaded correctly
-- Check Space logs for errors
-
-### "Model weights not found"
-- Ensure weights are in `weights/` directory
-- Check git-lfs tracked files: `git lfs ls-files`
-- Re-upload if needed
-
-### GPU timeout
-- Increase `@spaces.GPU(duration=X)` in app.py
-- Reduce image resolution
-- Process fewer reference images
-
-### Out of memory
-- Use lower resolution images
-- Process fewer objects simultaneously
-- Request more GPU resources in Space settings
-
-## Cost Optimization
-
-ZeroGPU is free but has usage limits:
-
-- **Development**: Use placeholder mode
-- **Testing**: Enable real mode for specific tests only
-- **Production**: Consider dedicated GPU deployment (RunPod, Modal, etc.)
-
-## Next Steps
-
-1. Test locally in placeholder mode
-2. Upload weights for real mode
-3. Integrate with robot-ml training pipeline
-4. Monitor GPU usage and costs
-5. Optimize batch processing for your use case
-
-## Support
-
-- **Issues**: https://github.com/gpuschel/robot-ml/issues
-- **FoundationPose**: https://github.com/NVlabs/FoundationPose
-- **HF Spaces**: https://huggingface.co/docs/hub/spaces

README_SETUP.md

@@ -1,216 +0,0 @@
-# FoundationPose Setup Guide
-
-**Quick navigation to setup instructions:**
-
-## 🎯 Choose Your Path
-
-### Path 1: Test Without Weights (5 minutes)
-
-Just want to test the API structure?
-
-```bash
-cd foundationpose
-pip install -r requirements.txt
-python app.py
-```
-
-✅ Works immediately
-✅ No GPU needed
-✅ Returns valid API responses (empty results)
-✅ Perfect for developing client integrations
-
-→ **No additional setup needed!**
-
----
-
-### Path 2: Deploy with Real Weights (30 minutes)
-
-Want actual 6D pose estimation?
-
-**Step 1: Get Model Weights**
-
-Option A: **Create HF Model Repo** (Recommended)
-📖 **Guide:** [HF_MODEL_SETUP.md](HF_MODEL_SETUP.md) (Quick 5-min guide)
-📖 **Detailed:** [UPLOAD_WEIGHTS.md](UPLOAD_WEIGHTS.md) (Full instructions)
-
-```bash
-# Quick version:
-huggingface-cli login
-huggingface-cli repo create foundationpose-weights --type model
-huggingface-cli upload YOUR_USER/foundationpose-weights ./weights .
-```
-
-Option B: Manual Download (Not recommended)
-- Download from Google Drive
-- Use git-lfs to add to Space repo
-- More complex, slower
-
-**Step 2: Configure Space**
-
-Add environment variables in Space settings:
-```
-FOUNDATIONPOSE_MODEL_REPO=YOUR_USER/foundationpose-weights
-USE_HF_WEIGHTS=true
-USE_REAL_MODEL=true
-```
-
-**Step 3: Deploy**
-
-```bash
-git push origin main
-```
-
-Done! Space will auto-download weights on first run.
-
----
-
-## 📚 Documentation Index
-
-| Document | Purpose | Read When |
-|----------|---------|-----------|
-| [HF_MODEL_SETUP.md](HF_MODEL_SETUP.md) | **Quick HF model repo setup** | Setting up weights (recommended way) |
-| [UPLOAD_WEIGHTS.md](UPLOAD_WEIGHTS.md) | Detailed weight upload guide | Need step-by-step instructions |
-| [QUICKSTART.md](QUICKSTART.md) | API usage & integration | Ready to use the API |
-| [DEPLOYMENT.md](DEPLOYMENT.md) | Full deployment options | Want all the details |
-| [STATUS.md](STATUS.md) | Complete project status | Want to know what's done/missing |
-| [README.md](README.md) | Space homepage | First-time visitors |
-
----
-
-## 🚀 Deployment Options Summary
-
-### A. Placeholder Mode (Default)
-
-```bash
-# No setup needed
-git push origin main
-```
-
-- Returns empty results
-- Tests API structure
-- No GPU costs
-- Perfect for development
-
-### B. Real Mode (Automatic Download)
-
-```bash
-# 1. Upload weights to HF model repo (see HF_MODEL_SETUP.md)
-# 2. Set Space environment variables:
-#    FOUNDATIONPOSE_MODEL_REPO=YOUR_USER/foundationpose-weights
-#    USE_HF_WEIGHTS=true
-#    USE_REAL_MODEL=true
-# 3. Deploy
-git push origin main
-```
-
-- Automatic weight download
-- Real pose estimation
-- ZeroGPU inference
-- Production-ready
-
-### C. Real Mode (Manual Weights)
-
-```bash
-# 1. Download weights manually
-# 2. Add with git-lfs
-git lfs track "weights/**"
-git add weights/
-git commit -m "Add weights"
-# 3. Set USE_REAL_MODEL=true
-git push origin main
-```
-
-- Weights included in Space
-- Slower deployments
-- Larger Space size
-- Not recommended
-
----
-
-## 🔗 Integration with robot-ml
-
-Once your Space is running:
-
-**1. Update wrapper:**
-```python
-from foundationpose.client import FoundationPoseClient
-
-client = FoundationPoseClient("https://YOUR_USER-foundationpose.hf.space")
-```
-
-**2. Update config:**
-```yaml
-perception:
-  enabled: true
-  model: foundation_pose
-  api_url: https://YOUR_USER-foundationpose.hf.space
-```
-
-**Full integration code:** See [QUICKSTART.md](QUICKSTART.md#integration-with-robot-ml)
-
----
-
-## ❓ FAQ
-
-**Q: Do I need a GPU?**
-A: No. ZeroGPU allocates GPU on-demand when needed.
-
-**Q: How much does it cost?**
-A: ZeroGPU is free with usage limits. Placeholder mode uses no GPU.
-
-**Q: Can I use someone else's weights?**
-A: Yes! If someone has a public model repo: `FOUNDATIONPOSE_MODEL_REPO=their-username/foundationpose-weights`
-
-**Q: How big are the weights?**
-A: ~1.8GB total (900MB refiner + 900MB scorer)
-
-**Q: Where do I get the weights?**
-A: Download from [Google Drive](https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da) then upload to HF model repo.
-
-**Q: Can I test locally?**
-A: Yes! `python test_local.py` tests everything locally first.
-
-**Q: What if weight download fails?**
-A: Space will run in placeholder mode automatically. Check logs for errors.
-
----
-
-## 🎯 Recommended Workflow
-
-```
-1. Test locally first
-   → python test_local.py
-
-2. Deploy placeholder mode
-   → Test Space works
-
-3. Create HF model repo
-   → Upload weights
-   → See HF_MODEL_SETUP.md
-
-4. Enable real mode
-   → Set environment variables
-   → Space auto-downloads weights
-
-5. Integrate with robot-ml
-   → See QUICKSTART.md
-```
-
----
-
-## 🆘 Getting Help
-
-- **General questions:** See [QUICKSTART.md](QUICKSTART.md)
-- **Deployment issues:** See [DEPLOYMENT.md](DEPLOYMENT.md)
-- **Weight upload:** See [UPLOAD_WEIGHTS.md](UPLOAD_WEIGHTS.md) or [HF_MODEL_SETUP.md](HF_MODEL_SETUP.md)
-- **Project status:** See [STATUS.md](STATUS.md)
-- **API usage:** See [QUICKSTART.md](QUICKSTART.md)
-
----
-
-**Start here:**
-→ Test locally: `python test_local.py`
-→ Want real weights: [HF_MODEL_SETUP.md](HF_MODEL_SETUP.md)
-→ Deploy: `git push origin main`
-
-That's it! 🎉

STATUS.md

@@ -1,383 +0,0 @@
-# FoundationPose Deployment - Current Status
-
-**Last Updated:** 2026-01-28
-**Repository:** `/Users/georgpuschel/repos/robot-ml/foundationpose/`
-**Hugging Face Space:** https://huggingface.co/spaces/gpue/foundationpose
-
----
-
-## 📦 What's Been Completed
-
-### Core Files Created
-
-1. **app.py** (570 lines)
-   - Complete Gradio application with ZeroGPU integration
-   - Dual mode: Placeholder (default) and Real FoundationPose
-   - REST API endpoints: `/api/initialize` and `/api/estimate`
-   - Web UI with tabs for initialization, estimation, and API docs
-   - Environment variable `USE_REAL_MODEL` controls mode
-
-2. **estimator.py** (350+ lines)
-   - FoundationPoseEstimator class wrapping the real FoundationPose API
-   - Methods: `register_object()`, `estimate_pose()`, `reset_tracking()`
-   - Handles camera intrinsics, depth images, and segmentation masks
-   - Quaternion and rotation matrix conversions
-   - Mesh loading and reconstruction (placeholder for BundleSDF)
-
-3. **client.py** (200+ lines)
-   - Python client for calling the API from robot-ml
-   - FoundationPoseClient class with initialize() and estimate_pose()
-   - Image encoding/decoding utilities
-   - Example usage code
-
-4. **requirements.txt**
-   - Core dependencies: gradio, spaces, torch, opencv-python
-   - 3D vision: trimesh, pyrender, scikit-image
-   - Placeholder for FoundationPose installation
-
-5. **Dockerfile**
-   - CUDA 12.1 base image
-   - System dependencies (eigen3, OpenGL, etc.)
-   - FoundationPose repository clone and build
-   - NVDiffRast, Kaolin, PyTorch3D installation
-
-6. **download_weights.py**
-   - Script to check for and download model weights
-   - Instructions for manual weight setup
-   - Git-LFS integration guide
-
-7. **deploy.sh**
-   - Interactive deployment script
-   - Checks for weights and git status
-   - Offers placeholder vs real mode deployment
-   - Guides through git-lfs setup
-
-8. **Documentation**
-   - README.md (updated with full details)
-   - DEPLOYMENT.md (step-by-step deployment guide)
-   - QUICKSTART.md (quick start for both modes)
-   - STATUS.md (this file)
-
-9. **.gitignore**
-   - Python cache files
-   - Virtual environments
-   - Model weights (for git-lfs)
-   - Test images
-
----
-
-## 🎯 How It Works
-
-### Placeholder Mode (Default)
-
-- **Purpose**: API testing without GPU requirements
-- **Behavior**: Returns empty pose results with success=true
-- **Use Cases**:
-  - Developing client integrations
-  - Testing API structure
-  - Demos without GPU costs
-
-### Real Mode (Requires Setup)
-
-- **Purpose**: Actual 6D pose estimation
-- **Requirements**:
-  - Model weights in `weights/` directory
-  - FoundationPose repository cloned
-  - Environment variable `USE_REAL_MODEL=true`
-- **Behavior**: Uses actual FoundationPose inference
-- **Use Cases**:
-  - Production pose estimation
-  - Validation and testing with real data
-  - Integration with robot-ml training
-
----
-
-## 🚀 Deployment Options
-
-### Option 1: Test Locally (Placeholder)
-
-```bash
-cd foundationpose
-pip install -r requirements.txt
-python app.py
-# Visit http://localhost:7860
-```
-
-### Option 2: Deploy to HF (Placeholder)
-
-```bash
-./deploy.sh
-# Or manually:
-git add .
-git commit -m "Deploy FoundationPose Space"
-git push origin main
-```
-
-### Option 3: Deploy to HF (Real Mode)
-
-**Requirements:**
-1. Download weights from Google Drive
-2. Set up git-lfs
-3. Enable USE_REAL_MODEL=true
-
-**Steps:**
-```bash
-# 1. Download weights (manual step)
-# Visit: https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da
-# Extract to: weights/2023-10-28-18-33-37/ and weights/2024-01-11-20-02-45/
-
-# 2. Set up git-lfs
-git lfs install
-git lfs track "weights/**"
-git add .gitattributes
-
-# 3. Add weights
-git add weights/
-git commit -m "Add model weights"
-
-# 4. Deploy
-git push origin main
-
-# 5. Set Space secret: USE_REAL_MODEL=true
-```
-
----
-
-## 🔗 Integration with robot-ml
-
-### Update FoundationPose Wrapper
-
-Edit `/training/nova_sim_trainer/perception/foundation_pose_wrapper.py`:
-
-```python
-from foundationpose.client import FoundationPoseClient
-from pathlib import Path
-import cv2
-
-class FoundationPoseWrapper(PoseEstimator):
-    def __init__(self, api_url: str, tracked_objects: List[Dict], **kwargs):
-        super().__init__()
-        self.client = FoundationPoseClient(api_url)
-        self.object_ids = []
-
-        # Initialize each tracked object
-        for obj_config in tracked_objects:
-            if not obj_config.get("enabled", True):
-                continue
-
-            object_id = obj_config["object_id"]
-            ref_dir = Path(obj_config["reference_images_dir"])
-
-            # Load reference images
-            ref_images = []
-            for img_path in sorted(ref_dir.glob("*.jpg")):
-                img = cv2.imread(str(img_path))
-                img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                ref_images.append(img)
-
-            # Register object with API
-            logger.info(f"Registering {object_id} with {len(ref_images)} images...")
-            self.client.initialize(object_id, ref_images)
-            self.object_ids.append(object_id)
-
-    def estimate_poses(self, frame, camera_intrinsics, scene_objects):
-        detected_poses = []
-
-        for object_id in self.object_ids:
-            poses = self.client.estimate_pose(object_id, frame, camera_intrinsics)
-
-            for pose in poses:
-                detected_poses.append(DetectedPose(
-                    object_id=pose["object_id"],
-                    position=pose["position"],
-                    orientation=pose["orientation"],
-                    confidence=pose["confidence"],
-                    timestamp=0.0,
-                    dimensions=tuple(pose.get("dimensions", [0.1, 0.1, 0.1]))
-                ))
-
-        return detected_poses
-```
-
-### Update Configuration
-
-Edit `/training/observations.yaml`:
-
-```yaml
-perception:
-  enabled: true
-  model: foundation_pose
-  api_url: https://gpue-foundationpose.hf.space  # Your deployed Space URL
-  camera: aux_top
-  inference_fps: 5
-
-  tracked_objects:
-    - object_id: target_cube
-      scene_object_name: t_object
-      enabled: true
-      reference_images_dir: ./perception/reference/target_cube
-      dimensions: [0.1, 0.1, 0.1]
-```
-
----
-
-## ⚠️ What's NOT Done Yet
-
-### Missing Pieces
-
-1. **Model Weights**
-   - Not included in repo (too large)
-   - Must be downloaded manually
-   - Requires git-lfs setup
-
-2. **FoundationPose Repository**
-   - Not included (git submodule or clone needed)
-   - C++ extensions need to be built
-   - Tested only with placeholder code
-
-3. **BundleSDF Integration**
-   - Mesh reconstruction not implemented
-   - Currently uses placeholder cube mesh
-   - Needed for model-free mode
-
-4. **Segmentation**
-   - Object segmentation uses placeholder mask
-   - Should integrate SAM (Segment Anything Model)
-   - Optional but improves accuracy
-
-5. **Pose Visualization**
-   - Estimation results don't show overlays yet
-   - TODO: Render detected pose on query image
-   - Would improve debugging
-
-### Testing Status
-
-- ✅ Placeholder mode tested locally
-- ⚠️ Real mode NOT tested (no weights)
-- ⚠️ API integration NOT tested end-to-end
-- ⚠️ ZeroGPU behavior unknown (not deployed yet)
-
----
-
-## 📊 Performance Expectations
-
-### ZeroGPU Characteristics
-
-- **Cold Start**: 15-30 seconds (GPU allocation + model loading)
-- **Warm Inference**: 0.5-2 seconds per query
-- **Free Tier**: Limited monthly usage
-- **Timeout**: GPU allocation lasts for duration specified in decorator
-
-### robot-ml Training Integration
-
-**Not suitable for real-time training loop (30 Hz):**
-- 5 Hz perception requires 200ms per frame
-- ZeroGPU latency: 500ms-2s warm, 15-30s cold
-- ❌ Too slow for synchronous training
-
-**Suitable for:**
-- ✅ Batch processing recorded episodes
-- ✅ Validation and testing
-- ✅ Demos and visualization
-- ✅ Reference data collection
-
-**Recommendation:**
-- Use dummy estimator during training (reads ground truth from sim)
-- Use FoundationPose API for validation/testing only
-- Consider local GPU deployment for production
-
----
-
-## 📝 Next Steps
-
-### Immediate (Before Deployment)
-
-1. **Test Locally**
-   ```bash
-   cd foundationpose
-   python app.py
-   # Test UI at http://localhost:7860
-   ```
-
-2. **Deploy Placeholder Mode**
-   ```bash
-   ./deploy.sh
-   # Choose "N" for real mode
-   ```
-
-3. **Verify Space Works**
-   - Visit https://huggingface.co/spaces/gpue/foundationpose
-   - Test initialization with test images
-   - Check logs for errors
-
-### Short Term (With Weights)
-
-1. **Download Model Weights**
-   - Get from Google Drive (see DEPLOYMENT.md)
-   - Extract to `weights/` directory
-
-2. **Test Real Mode Locally**
-   ```bash
-   export USE_REAL_MODEL=true
-   python app.py
-   # Upload real reference images
-   # Test pose estimation
-   ```
-
-3. **Deploy Real Mode**
-   ```bash
-   # Set up git-lfs
-   git lfs track "weights/**"
-   git add .gitattributes weights/
-   git commit -m "Add model weights"
-   git push
-
-   # Set Space secret: USE_REAL_MODEL=true
-   ```
-
-### Long Term (Production)
-
-1. **Optimize Performance**
-   - Implement batch inference
-   - Add caching for frequently used objects
-   - Tune GPU duration parameters
-
-2. **Improve Accuracy**
-   - Integrate SAM for segmentation
-   - Add depth image support
-   - Implement BundleSDF reconstruction
-
-3. **Production Deployment**
-   - Consider dedicated GPU (RunPod, Modal, etc.)
-   - Set up monitoring and logging
-   - Implement retry logic and error handling
-
----
-
-## 📚 Reference Links
-
-- **FoundationPose GitHub**: https://github.com/NVlabs/FoundationPose
-- **Research Paper**: https://arxiv.org/abs/2312.08344
-- **Model Weights**: https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da
-- **HF Spaces Docs**: https://huggingface.co/docs/hub/spaces
-- **ZeroGPU Docs**: https://huggingface.co/docs/hub/spaces-gpus-zerogpu
-- **Gradio Docs**: https://www.gradio.app/docs
-
----
-
-## 🤝 Citation
-
-If you use this in your work:
-
-```bibtex
-@inproceedings{wen2023foundationpose,
-  title={FoundationPose: Unified 6D Pose Estimation and Tracking of Novel Objects},
-  author={Wen, Bowen and Yang, Wei and Kautz, Jan and Birchfield, Stan},
-  booktitle={CVPR},
-  year={2024}
-}
-```
-
----
-
-**Summary:** The FoundationPose Space is fully set up and ready to deploy. It defaults to placeholder mode (no GPU needed) for testing the API structure. To enable real pose estimation, you need to manually download the model weights and set USE_REAL_MODEL=true. The integration code for robot-ml is ready but untested without the actual weights.

UPLOAD_WEIGHTS.md

@@ -1,328 +0,0 @@
-# How to Upload FoundationPose Weights to Hugging Face
-
-This guide shows you how to host FoundationPose model weights in a Hugging Face model repository, which is much better than using git-lfs in your Space.
-
-## Why Use a Model Repository?
-
-✅ **Benefits:**
-- Designed for large files (GB+)
-- Fast CDN downloads
-- Version control for weights
-- Share weights across multiple Spaces
-- No need for git-lfs in Space repo
-- Better download performance
-
-## Step-by-Step Guide
-
-### 1. Download Official Weights
-
-First, get the official FoundationPose weights from Google Drive:
-
-**Download Link:** https://drive.google.com/drive/folders/1GCyGE-LbFGgRC-FuGsF3a1zeBuzsQ1Da
-
-Download these two folders:
-- `2023-10-28-18-33-37/` (refiner weights, ~900MB)
-- `2024-01-11-20-02-45/` (scorer weights, ~900MB)
-
-Save them locally in a directory structure like:
-```
-foundationpose-weights/
-├── 2023-10-28-18-33-37/
-│   ├── model.pth
-│   └── ...
-└── 2024-01-11-20-02-45/
-    ├── model.pth
-    └── ...
-```
-
-### 2. Create Hugging Face Model Repository
-
-**Option A: Using the Web Interface**
-
-1. Go to https://huggingface.co/new
-2. Choose "Model" (not Space or Dataset)
-3. Set owner to your username (e.g., `gpue`)
-4. Set name: `foundationpose-weights`
-5. Make it **Public** (so your Space can download it) or Private (requires token)
-6. Click "Create model"
-
-**Option B: Using the CLI**
-
-```bash
-pip install huggingface_hub
-huggingface-cli login  # Enter your token
-
-# Create repo
-huggingface-cli repo create foundationpose-weights --type model
-```
-
-### 3. Upload Weights to Model Repository
-
-**Option A: Using the Web Interface**
-
-1. Go to your model repo: `https://huggingface.co/YOUR_USERNAME/foundationpose-weights`
-2. Click "Files" → "Add file" → "Upload files"
-3. Drag and drop the two weight folders
-4. Click "Commit changes"
-
-⚠️ **Note:** Web upload may be slow for large files. Use CLI for better experience.
-
-**Option B: Using the CLI (Recommended)**
-
-```bash
-# From the directory containing your weight folders
-huggingface-cli upload YOUR_USERNAME/foundationpose-weights ./2023-10-28-18-33-37 2023-10-28-18-33-37
-huggingface-cli upload YOUR_USERNAME/foundationpose-weights ./2024-01-11-20-02-45 2024-01-11-20-02-45
-```
-
-**Option C: Using Python Script**
-
-```python
-from huggingface_hub import HfApi
-from pathlib import Path
-
-api = HfApi()
-repo_id = "YOUR_USERNAME/foundationpose-weights"
-weights_dir = Path("./foundationpose-weights")
-
-print("Uploading weights to Hugging Face...")
-
-# Upload entire directory
-api.upload_folder(
-    folder_path=str(weights_dir),
-    repo_id=repo_id,
-    repo_type="model"
-)
-
-print("✓ Upload complete!")
-```
-
-### 4. Add Model Card (README)
-
-Create a `README.md` in your model repo to document the weights:
-
-```markdown
----
-license: cc-by-nc-4.0
-tags:
-  - computer-vision
-  - 6d-pose-estimation
-  - object-detection
-  - robotics
----
-
-# FoundationPose Model Weights
-
-Pre-trained weights for [FoundationPose](https://github.com/NVlabs/FoundationPose) 6D object pose estimation model.
-
-## Model Details
-
-- **Refiner weights:** `2023-10-28-18-33-37/`
-- **Scorer weights:** `2024-01-11-20-02-45/`
-- **Source:** [Official FoundationPose release](https://github.com/NVlabs/FoundationPose)
-
-## Usage
-
-```python
-from huggingface_hub import snapshot_download
-
-# Download all weights
-snapshot_download(
-    repo_id="YOUR_USERNAME/foundationpose-weights",
-    local_dir="./weights"
-)
-```
-
-## Citation
-
-```bibtex
-@inproceedings{wen2023foundationpose,
-  title={FoundationPose: Unified 6D Pose Estimation and Tracking of Novel Objects},
-  author={Wen, Bowen and Yang, Wei and Kautz, Jan and Birchfield, Stan},
-  booktitle={CVPR},
-  year={2024}
-}
-```
-
-## License
-
-These weights are from the official FoundationPose release and subject to NVIDIA's license terms.
-```
-
-### 5. Configure Your Space to Use the Model Repo
-
-Update your Space's environment variables (Settings → Variables and secrets):
-
-```
-FOUNDATIONPOSE_MODEL_REPO=YOUR_USERNAME/foundationpose-weights
-USE_HF_WEIGHTS=true
-USE_REAL_MODEL=true
-```
-
-Or set in your Space's Dockerfile/code:
-
-```python
-import os
-os.environ["FOUNDATIONPOSE_MODEL_REPO"] = "gpue/foundationpose-weights"
-os.environ["USE_HF_WEIGHTS"] = "true"
-```
-
-### 6. Test the Setup
-
-**Test locally:**
-
-```bash
-cd foundationpose
-
-# Set environment variables
-export FOUNDATIONPOSE_MODEL_REPO="YOUR_USERNAME/foundationpose-weights"
-export USE_HF_WEIGHTS="true"
-
-# Download weights
-python download_weights.py
-
-# Should see:
-# ✓ Download complete!
-# ✓ Model weights found locally!
-```
-
-**Test in Space:**
-
-After pushing to HF Spaces, check the build logs:
-1. Go to your Space → Logs
-2. Look for "Downloading from Hugging Face Model Repository"
-3. Should see "✓ Download complete!"
-
-### 7. Verify Weights Are Correct
-
-Check that the downloaded structure matches:
-
-```bash
-ls -R weights/
-
-# Should show:
-# weights/2023-10-28-18-33-37/
-# weights/2024-01-11-20-02-45/
-```
-
-## Troubleshooting
-
-### "Repository not found"
-
-- Check repo name matches exactly: `YOUR_USERNAME/foundationpose-weights`
-- Make sure repo is Public, or provide HF token for private repos
-- Verify you're logged in: `huggingface-cli whoami`
-
-### "Upload failed"
-
-- Check your internet connection
-- Try uploading smaller chunks
-- Use CLI instead of web interface for large files
-
-### "Out of storage"
-
-- HF free tier has storage limits (~50GB)
-- Request more storage or use smaller model variants
-- Host on your own S3/CDN as alternative
-
-### Private Repository Access
-
-If your model repo is private, set HF token in Space secrets:
-
-1. Get token from https://huggingface.co/settings/tokens
-2. Add to Space: Settings → Repository secrets → `HF_TOKEN`
-3. Code will automatically use it:
-
-```python
-from huggingface_hub import snapshot_download
-import os
-
-snapshot_download(
-    repo_id="YOUR_USERNAME/foundationpose-weights",
-    local_dir="./weights",
-    token=os.environ.get("HF_TOKEN")  # Uses secret
-)
-```
-
-## Example: Complete Workflow
-
-```bash
-# 1. Download from Google Drive (manual)
-# Save to: ~/Downloads/foundationpose-weights/
-
-# 2. Install HF CLI
-pip install huggingface_hub
-huggingface-cli login
-
-# 3. Create model repo
-huggingface-cli repo create foundationpose-weights --type model
-
-# 4. Upload weights
-cd ~/Downloads/foundationpose-weights
-huggingface-cli upload gpue/foundationpose-weights . .
-
-# 5. Update your Space
-cd /path/to/foundationpose
-git add .
-git commit -m "Use HF model repo for weights"
-git push
-
-# 6. Set Space secrets
-# Go to: https://huggingface.co/spaces/gpue/foundationpose/settings
-# Add: FOUNDATIONPOSE_MODEL_REPO=gpue/foundationpose-weights
-# Add: USE_HF_WEIGHTS=true
-# Add: USE_REAL_MODEL=true
-
-# 7. Check Space logs
-# Visit: https://huggingface.co/spaces/gpue/foundationpose/logs
-# Should see weights downloading automatically
-```
-
-## Alternative: Public Model Repos
-
-If someone else has already uploaded the weights, you can use their repo:
-
-```bash
-# Example (if available)
-export FOUNDATIONPOSE_MODEL_REPO="some-user/foundationpose-weights"
-```
-
-Common public repos (check if they exist):
-- `nvidia/foundationpose` (official, if available)
-- Community uploads (search on HF)
-
-## Cost
-
-✅ **Free tier:**
-- Unlimited model repos
-- ~50GB storage per repo
-- Unlimited downloads (public repos)
-- No bandwidth costs
-
-📈 **Pro tier ($9/month):**
-- More storage
-- Private repos with teams
-- Priority support
-
----
-
-**Quick Reference:**
-
-```bash
-# Create repo
-huggingface-cli repo create foundationpose-weights --type model
-
-# Upload
-huggingface-cli upload YOUR_USERNAME/foundationpose-weights ./weights .
-
-# Download in Space (automatic)
-python download_weights.py
-
-# Or download manually
-from huggingface_hub import snapshot_download
-snapshot_download("YOUR_USERNAME/foundationpose-weights", local_dir="./weights")
-```
-
----
-
-You're all set! Your FoundationPose Space will now automatically download weights from your model repository on first run. 🎉

app.py

@@ -8,6 +8,7 @@ import base64
 import json
 import logging
 import os
+from pathlib import Path
 from typing import Dict, List
 
 import cv2
@@ -26,6 +27,49 @@ logger = logging.getLogger(__name__)
 USE_REAL_MODEL = os.environ.get("USE_REAL_MODEL", "false").lower() == "true"
 
 
+def download_weights_if_needed():
+    """Download model weights from HuggingFace model repository if needed."""
+    weights_dir = Path("weights")
+
+    # Check if weights already exist
+    if weights_dir.exists() and any(weights_dir.glob("**/*.pth")):
+        logger.info("Model weights already exist locally")
+        return True
+
+    # Only download if USE_REAL_MODEL is enabled
+    if not USE_REAL_MODEL:
+        logger.info("Placeholder mode - skipping weight download")
+        return False
+
+    try:
+        from huggingface_hub import snapshot_download
+
+        model_repo = os.environ.get("FOUNDATIONPOSE_MODEL_REPO", "gpue/foundationpose-weights")
+        hf_token = os.environ.get("HF_TOKEN")
+
+        logger.info(f"Downloading model weights from {model_repo}...")
+
+        snapshot_download(
+            repo_id=model_repo,
+            local_dir=str(weights_dir),
+            token=hf_token,
+            repo_type="model"
+        )
+
+        logger.info("✓ Model weights downloaded successfully")
+        return True
+
+    except Exception as e:
+        logger.error(f"Failed to download weights: {e}")
+        logger.warning("Falling back to placeholder mode")
+        return False
+
+
+# Download weights at startup if needed
+logger.info("Checking model weights...")
+download_weights_if_needed()
+
+
 class FoundationPoseInference:
     """Wrapper for FoundationPose model inference."""