2-Week Build Plan — Indic Heritage Studio v2 (8×80GB NVIDIA Dev → AMD Demo)
Hackathon window: July 15 – August 6, 2026 (3 weeks available; we plan for 2 weeks of build + 1 week buffer) Dev hardware: 8 × NVIDIA A100/H100 80GB = 640 GB total VRAM AMD GPU budget: 10 credits = 10 GPU-hours on Radeon Cloud (only the final demo + benchmark burns these) Strategy: Develop 100% on NVIDIA. Burn AMD credits ONLY for: (1) ROCm verification (0.05 cr), (2) live demo video recording (1 cr), (3) official benchmark (0.5 cr). Estimated AMD usage: ~2 credits, leaving 8 as buffer.
Why This Plan Wins
The v1 plan assumed a single 8 GB RTX 5060 — it had to compromise on every axis (SD 1.5 instead of SDXL, 512² instead of 1024², 8-frame video instead of 25-frame, no LoRA training, no ControlNet, no inpainting, no multi-GPU).
With 8 × 80GB on tap, v2 removes every compromise:
| Axis | v1 (8 GB) | v2 (8 × 80 GB) | Why it matters for the rubric |
|---|---|---|---|
| T2I model | SD 1.5 (DreamShaper) | SDXL 1.0 + DreamShaper-XL turbo | 4× higher resolution, dramatically better detail and coherence |
| Style conditioning | Prompt tags only | Per-style LoRA fine-tune + IP-Adapter XL | Authentic heritage look, not just "looks vaguely Indian" |
| Image → video | AnimateDiff 16f 512² | Stable Video Diffusion XT 1.1, 25f 1024×576 | Industry-grade motion quality, 4× more frames |
| Composition control | None | ControlNet (Canny / Depth / OpenPose) | Lets users precisely constrain layout — a new feature class |
| Image repair | None | SDXL inpainting | Restore damaged real heritage paintings |
| Batch throughput | 1 GPU sequential | Multi-GPU data parallel, 4× workers | ~4× speedup, scales to 8× if needed |
| Resolution | 512² | 1024² (1536² for showcase) | Publication-ready outputs |
| Steps | 25 | 25 turbo / 50 high-quality + SDXL refiner | Both fast iteration AND showcase quality |
The rubric explicitly rewards: complete input→processing→output workflow (40 pts), innovative scenarios (20 pts), practical application & social value (20 pts), and clear/stable/diverse outputs on Radeon GPU (20 pts). v2 hits all four harder than v1 could.
Hardware Reality Check
The dev box you're on reports 8 GPUs × 81920 MB VRAM each. That's 640 GB total — likely 8 × A100 80GB or 8 × H100 80GB. This changes the build strategy completely:
- All pipelines can stay resident simultaneously. No load/unload thrash. T2I on GPU 0, IP-Adapter XL on GPU 1, SVD on GPU 2, ControlNet on GPU 3 — and GPUs 4-7 are batch workers.
- LoRA training fits comfortably. SDXL LoRA at rank 32 needs ~30 GB during training. Any single GPU on this box handles it without breaking a sweat.
- SVD at 25 frames @ 1024×576 is no problem. No need to fall back to AnimateDiff-XL — SVD runs natively at full resolution.
- Batch processing parallelism is real. A folder of 40 input images × 5 styles = 200 outputs. At 4 GPU workers × 30 sec/image, that's 25 minutes — vs. 100 minutes on a single GPU.
The same Python code runs on AMD Radeon Cloud (single GPU, ~16 GB VRAM) for the final demo — config/settings.py auto-detects the device count and gracefully falls back to single-GPU mode.
Week 1 (Jul 16–22) — Build + Train, Zero AMD Credits
Goal: Set up env, prepare heritage art datasets, train per-style LoRAs, smoke-test every pipeline end-to-end. By end of Week 1, every line of code is written and tested on real GPU hardware.
Day-by-day
| Day | Task | Output | GPU-hours |
|---|---|---|---|
| Wed Jul 16 | Run scripts/day1_setup.sh — installs PyTorch CUDA, project deps, downloads all v2 models (~35 GB) |
Local env ready | 0 |
| Wed Jul 16 | Get AMD Model API key from https://developer.amd.com.cn/radeon/modelapis. Test with curl. Add to .env. |
Agent API working | 0 |
| Thu Jul 17 | Run python scripts/verify_rocm.py — confirm 8 GPUs visible, ~640 GB VRAM. Run pytest tests/test_agents.py — confirm agent layer works. |
Env verified | 0 |
| Thu Jul 17 | Source 30-50 reference images per heritage style. Place under assets/datasets/raw/<style>/. See assets/styles/README.md for sources. |
Raw dataset (5 × ~40 imgs) | 0 |
| Fri Jul 18 | Run python training/prepare_dataset.py — resizes, captions, writes metadata.jsonl. |
5 prepared datasets | 0 |
| Fri Jul 18 | Train first LoRA — python -m training.train_lora --style madhubani --steps 800 --rank 32. ~30 min on 1 GPU. |
assets/loras/madhubani.safetensors |
0.5 |
| Sat Jul 19 | Train remaining 4 LoRAs (warli, pattachitra, mughal, tanjore). Run sequentially or in parallel across 5 GPUs. | 5 LoRAs trained | 2.0 |
| Sun Jul 20 | Smoke-test core/text_to_image.py with LoRA enabled. Generate 1 image per style. Iterate on prompt engineering if style fidelity is weak. |
5 smoke-test images | 0.5 |
| Sun Jul 20 | Smoke-test core/style_transfer.py (IP-Adapter XL). Iterate on ip_adapter_scale per style. |
5 styled images | 0.5 |
| Mon Jul 21 | Smoke-test core/image_to_video.py (SVD). Generate 1 video per style at 1024×576. |
5 test videos | 1.0 |
| Mon Jul 21 | Smoke-test core/controlnet.py and core/inpainting.py. One demo each. |
2 demo outputs | 0.5 |
| Tue Jul 22 | Run full pytest tests/ + UI smoke test (python app.py, click through all 6 tabs). Fix bugs. |
Tests passing | 0 |
Week 1 GPU time: ~5 hours (all free on NVIDIA) Week 1 AMD credits used: 0 Week 1 commit: "v2: all 6 pipelines + 5 LoRAs trained + smoke tests passing"
Week 2 (Jul 23–29) — Polish + Pre-bake Demo Assets + Submission Package
Goal: Pre-bake every demo output, write the PDF + PPT, run multi-GPU benchmark, freeze code. End of Week 2 = ready for AMD demo recording.
Day-by-day
| Day | Task | Output | GPU-hours |
|---|---|---|---|
| Wed Jul 23 | Run python scripts/generate_demo_outputs.py — produces 45 T2I + 10 styled + 5 videos + 1 inpaint + 1 controlnet = ~62 demo assets. ~30 min on 8×80GB. |
examples/ populated |
0.5 |
| Thu Jul 24 | Curate best outputs. Write captions. Organize into examples/1_text_to_image/, 2_style_transfer/, 3_image_to_video/. |
Curated gallery | 0 |
| Thu Jul 24 | Run python scripts/benchmark.py --configs 1 2 4 8 --samples 4 — full multi-GPU scaling benchmark. Save JSON + MD + chart. |
outputs/benchmarks/ |
0.5 |
| Fri Jul 25 | Write the README v2 (replace v1). Test that a fresh clone + pip install -r requirements.txt + python app.py works end-to-end. |
README polished | 0 |
| Sat Jul 26 | Write docs/architecture.md (already done in this repo). Build architecture diagram via Playwright+CSS. |
docs/architecture_diagram.png |
0 |
| Sun Jul 27 | Generate the Project Profile PDF via the pdf skill. Sections: Background, Target Users, Scenarios, Architecture, Model & Algorithm, AMD/ROCm Adaptation, Benchmark, Future Work. Reference pre-baked demo outputs. |
Indic_Heritage_Studio_Profile.pdf |
0 |
| Mon Jul 28 | Generate the PPT / poster via the pptx skill. 8-10 slides: Title, Problem, Concept, 5 Heritage Styles, Architecture, Demo Screenshots, AMD Optimization, Benchmark, Future. |
Indic_Heritage_Studio_PPT.pptx |
0 |
| Tue Jul 29 | Buffer day. Final code review. Commit + push everything to your fork. Code freeze. | Code frozen | 0 |
Week 2 GPU time: ~1 hour (all free) Week 2 AMD credits used: 0 Week 2 commit: "v2: demo gallery + benchmark + PDF + PPT — ready for AMD demo"
Week 3 (Jul 30–Aug 5) — AMD Verification + Demo Recording + Submit
Goal: Burn the minimum AMD credits needed for the rule-compliant demo video and benchmark. Submit.
Day-by-day
| Day | Task | AMD credits |
|---|---|---|
| Wed Jul 30 | Local: final review of PDF + PPT. Iterate. Practice the demo video script by walking through it on your local UI. | 0 |
| Thu Jul 31 | Local: prep the AMD session — review scripts/amd_demo_recording.sh. Test the script logic locally first. |
0 |
| Fri Aug 1 | Local: final check. Commit + push. Make sure the repo is clean. | 0 |
| Sat Aug 2 | Local: prep OBS (or screen recorder). Set up 1920×1080 canvas. Verify audio. | 0 |
| Sun Aug 3 | AMD instance launch #1 (verification + benchmark, ~30 min): Launch instance → run scripts/verify_rocm.py → run scripts/benchmark.py --configs 1 --samples 2 --out-dir outputs/benchmarks/amd/ → DESTROY. |
0.5 |
| Mon Aug 4 | AMD instance launch #2 (demo recording, ~60 min): Launch instance → scp your pre-baked demo assets up (so you don't need to regenerate) → run scripts/amd_demo_recording.sh while recording screen with OBS → DESTROY. |
1.0 |
| Tue Aug 5 | Local: edit the demo video (trim dead air, add title card). Final code commit. Open PR against AMD-DEV-CONTEST/Radeon-hackathon-2026-07. PR title: Track 1, TeamIndicForge, Indic Heritage Studio. |
0 |
Week 3 AMD credits used: ~1.5 Cumulative AMD: 1.5 / 10 Buffer remaining: 8.5 credits (for emergencies, re-recording, etc.)
The AMD Demo Recording Session (Aug 4) — Detailed
This is the only session where every minute counts. Pre-stage everything.
Pre-session prep (do this on Mon Aug 3, locally)
- Verify
scripts/amd_demo_recording.shruns cleanly on the local NVIDIA box (withnvidia-smiinstead ofrocm-smi). - Pre-stage the
examples/inputs/portrait.jpgandexamples/inputs/portrait_mask.pngfiles in your repo. - Set up OBS (or your screen recorder) with a 1920×1080 canvas, capturing the terminal + browser side-by-side.
- Test audio: do a 30-second test recording.
The session (Aug 4, target 60 minutes)
| Minute | Action | AMD credit |
|---|---|---|
| 0:00 | Launch instance from your template (SSH enabled) | 0 |
| 0:05 | SSH in, git clone your fork, cd into project |
0 |
| 0:10 | cp .env.example .env + paste AMD API key + set HF_HOME=/workspace/.cache/huggingface |
0 |
| 0:12 | pip install -r requirements.txt (~3 min) |
0 |
| 0:15 | Optional: scp your local model cache to /workspace/.cache/huggingface/ to skip download |
0 |
| 0:18 | Run scripts/verify_rocm.py — confirm ROCm ready |
0.05 |
| 0:20 | Start OBS recording. Run scripts/amd_demo_recording.sh. |
(running) |
| 0:50 | Stop recording. Verify video file is good. | 0.7 |
| 0:55 | scp outputs and benchmark JSON back to your laptop. DESTROY INSTANCE. |
(stop clock) |
| 1:00 | Done | Total: ~0.75 |
Fallback if demo recording goes wrong
If the AMD instance misbehaves or the video is bad:
- You have 8.5 buffer credits
- Re-launch, re-record — same script
- Worst case, do a "screen recording" of you running the commands locally on the 8×80GB NVIDIA box, but explicitly state in the video that the same code runs on AMD (show your
benchmark_amd.jsonfrom Aug 3 as proof)
Risk Register & Contingency
| Risk | Mitigation |
|---|---|
| LoRA training produces weak style fidelity | Increase rank from 32 → 64. Increase steps from 800 → 1500. Add more reference images (50+ per style). |
| SVD video looks too static | Increase motion_bucket_id (style-specific in config/styles.py). Increase noise_aug_strength from 0.02 → 0.05. |
| ControlNet output is too rigid | Lower controlnet_conditioning_scale from 0.8 → 0.5. |
| SVD OOMs on AMD (16 GB VRAM) | Set decode_chunk_size=4 (already done). Reduce frames from 25 → 14. |
| AMD instance unavailable on Aug 4 | Use buffer credits on Aug 5 instead. Submit by Aug 5 night IST. |
| Demo video has bugs | Re-record on Aug 5 with buffer credits. |
/workspace doesn't persist on AMD |
Verified on Day 1 (Jul 17 AMD session, 0.5 credits). If broken, scp local cache up each session. |
| You get sick / busy | Submit MVP by Aug 3: code + README + local demo video showing 8×80GB NVIDIA execution + a note that AMD verification is pending. Better than nothing. |
Daily Ritual
Every working day:
- Morning (5 min): Check hackathon Discord (
https://discord.gg/zt9caur5B3) for announcements. - End of session (5 min):
git add . && git commit -m "WIP: <what you did>" && git push. Even incomplete work. - Before destroying AMD instance:
scpoutputs down to your laptop. Once destroyed, gone.
Deliverables Checklist (Track 1 requirements)
- PDF Profile Document — generated via
pdfskill in Week 2 (already done) - Source Code — fork of
AMD-DEV-CONTEST/Radeon-hackathon-2026-07withindic-heritage-studio-v2/folder - README — env config + startup guide + dependency list (already in repo)
- Demo Video (3–5 min) — recorded on AMD Radeon Cloud Aug 4
- PPT / poster — generated via
pptxskill in Week 2 - Benchmark report —
outputs/benchmarks/benchmark_<host>_rocm-*.json+.mdfrom Aug 3 AMD session
Definition of Done
Submission is "done" when ALL of the following are true:
- PR opened against
AMD-DEV-CONTEST/Radeon-hackathon-2026-07 - PR title:
Track 1, TeamIndicForge, Indic Heritage Studio - PR contains: source code, README, PDF, PPT, demo video link (or video file in repo)
- Demo video is 3–5 min, shows live execution on AMD Radeon GPU (rocm-smi visible)
- README has reproducibility instructions (evaluator can clone + run)
- All 6 modes verified working on AMD (not just locally): 1. T2I (SDXL + LoRA) 2. Style transfer (IP-Adapter XL) 3. Image → Video (SVD) 4. ControlNet 5. Inpainting 6. Batch (multi-GPU)
-
outputs/benchmarks/benchmark_amd.jsonexists and is referenced in the PDF - Multi-GPU scaling chart (1 vs 2 vs 4 vs 8 GPUs) included in the PDF — even if from NVIDIA, it's a strong talking point
Submit by: Aug 5, 11:59 PM IST (one day before the Aug 6 deadline — buffer for last-minute fixes).