cleanup

BUILD.md

@@ -1,171 +0,0 @@
-# Two-Stage Docker Build
-
-FoundationPose requires CUDA C++ extensions that must be compiled with a GPU present. To enable local development and avoid build failures, we use a two-stage build process:
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────┐
-│ Stage 1: Base Image (Local, No GPU)            │
-│ - Install system dependencies                   │
-│ - Install PyTorch + Python packages             │
-│ - Clone FoundationPose repository               │
-│ - Patch setup.py for C++17                     │
-│ Build locally → Push to DockerHub              │
-└─────────────────────────────────────────────────┘
-                      ↓
-┌─────────────────────────────────────────────────┐
-│ Stage 2: Final Image (HuggingFace, GPU)        │
-│ FROM gpue/foundationpose-base:latest           │
-│ - Compile mycuda C++ extension (needs GPU)     │
-│ - Compile mycpp C++ extension                  │
-│ - Download model weights                       │
-│ Build on HuggingFace Spaces with GPU           │
-└─────────────────────────────────────────────────┘
-```
-
-## Files
-
-- **Dockerfile.base** - Stage 1: Base image without GPU compilation
-- **Dockerfile** - Stage 2: Final image that compiles CUDA extensions
-- **build_base.sh** - Build base image only
-- **deploy.sh** - Full two-stage deployment
-
-## Quick Start
-
-### Option 1: Automated Deployment
-
-```bash
-cd /Users/georgpuschel/repos/robot-ml/foundationpose
-
-# Login to DockerHub
-docker login
-
-# Run full deployment (builds base, pushes to DockerHub, deploys to HF, follows logs)
-./deploy.sh
-```
-
-The script will:
-1. Build the base image for linux/amd64
-2. Push to DockerHub as `gpue/foundationpose-base:latest`
-3. Commit and push changes to HuggingFace
-4. Automatically follow the HuggingFace build logs (press Ctrl+C to stop)
-
-**Prerequisites**:
-- Docker login credentials for DockerHub
-- HuggingFace token in `../training/.env.local` (for following logs)
-
-### Option 2: Manual Steps
-
-#### Step 1: Build and Push Base Image
-
-```bash
-# Build for linux/amd64 (HuggingFace platform)
-docker build --platform linux/amd64 -f Dockerfile.base -t gpue/foundationpose-base:latest .
-
-# Push to DockerHub
-docker login
-docker push gpue/foundationpose-base:latest
-```
-
-#### Step 2: Deploy to HuggingFace
-
-```bash
-# Add the git remote (if not already added)
-git remote add hf https://huggingface.co/spaces/gpue/foundationpose
-
-# Push updated Dockerfile to HuggingFace
-git add Dockerfile Dockerfile.base
-git commit -m "Two-stage build: base image + GPU compilation"
-git push hf main
-```
-
-HuggingFace will automatically:
-1. Pull `gpue/foundationpose-base:latest` from DockerHub
-2. Compile C++ extensions with GPU present
-3. Download model weights
-4. Start the application
-
-## Why Two Stages?
-
-**Problem**: CUDA C++ extensions fail to compile without a GPU:
-```
-TypeError: expected string or bytes-like object
-torch.version.cuda returns None when no GPU is present
-```
-
-**Solution**:
-- Stage 1 (Base): Everything except GPU compilation - can build anywhere
-- Stage 2 (Final): Only GPU-dependent compilation - builds on HuggingFace with GPU
-
-**Benefits**:
-- ✓ Build base image locally without GPU
-- ✓ Faster HuggingFace builds (base layers cached)
-- ✓ Easy to iterate on application code (stage 2 is small)
-- ✓ Base image can be reused across multiple projects
-
-## Troubleshooting
-
-### Platform Mismatch
-
-If you're on Apple Silicon (M1/M2/M3), you must specify `--platform linux/amd64`:
-
-```bash
-docker build --platform linux/amd64 -f Dockerfile.base -t gpue/foundationpose-base:latest .
-```
-
-### DockerHub Authentication
-
-```bash
-docker login
-# Enter username: gpue
-# Enter password: <your-dockerhub-token>
-```
-
-### Verify Base Image
-
-Test the base image locally (without GPU compilation):
-
-```bash
-docker run --rm -it gpue/foundationpose-base:latest bash
-
-# Inside container:
-python3 -c "import torch; print(torch.__version__)"
-ls /app/FoundationPose
-cat /app/FoundationPose/bundlesdf/mycuda/setup.py | grep "c++17"
-```
-
-### HuggingFace Build Logs
-
-Monitor the build on HuggingFace:
-
-```bash
-curl -H "Authorization: Bearer $HF_TOKEN" \
-  "https://huggingface.co/api/spaces/gpue/foundationpose/logs/build"
-```
-
-## Updating the Base Image
-
-When you need to change dependencies or system packages:
-
-1. Edit `Dockerfile.base`
-2. Rebuild and push:
-   ```bash
-   ./build_base.sh
-   docker push gpue/foundationpose-base:latest
-   ```
-3. Rebuild on HuggingFace (will pull updated base automatically)
-
-## Local Testing (Without GPU)
-
-To test the base image without GPU compilation:
-
-```bash
-# Build base
-docker build -f Dockerfile.base -t foundationpose-base-test .
-
-# Run without compiling extensions
-docker run --rm -p 7860:7860 foundationpose-base-test python3 app.py
-```
-
-The app will run in placeholder mode (no real inference) but you can test the UI and API endpoints.

build_base.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-# Build and push the base image to DockerHub
-
-set -e
-
-IMAGE_NAME="gpue/foundationpose-base"
-TAG="latest"
-PLATFORM="linux/amd64"  # HuggingFace Spaces use x86_64
-
-echo "Building base image for ${PLATFORM}: ${IMAGE_NAME}:${TAG}"
-docker build --platform ${PLATFORM} -f Dockerfile.base -t ${IMAGE_NAME}:${TAG} .
-
-echo ""
-echo "✓ Base image built successfully for ${PLATFORM}"
-echo ""
-echo "To push to DockerHub:"
-echo "  docker login"
-echo "  docker push ${IMAGE_NAME}:${TAG}"
-echo ""
-echo "After pushing, the HuggingFace Space will use this base image."