3D Animation LoRA Pipeline

Portfolio-ready data engineering and training pipeline for animation LoRA datasets. The project turns animation footage into staged artifacts: frames, detections, foreground/background cutouts, pose records, embeddings, LoRA-ready datasets, inference samples, animation frames, and a public demo layer that is safe to show without private media or model weights.

The repository is intentionally file-driven. There is no production database or hosted API server. YAML/TOML configs, parquet metadata, image artifacts, and static JSON manifests are the contracts between stages.

Demo Links

Quick Reviewer Path

pip install -r requirements/core.txt -r requirements/dev.txt
python scripts/demo/run_demo_pipeline.py --skip-pipeline
python -m pytest tests/demo -q
python -m http.server 8080 -d portfolio-web

Open http://localhost:8080.

If you want the full demo-safe smoke suite:

./tests/run_tests.sh

What This Project Demonstrates

Product Demo Flow

flowchart LR
    A[Reviewer opens portfolio card] --> B[Project detail page]
    B --> C[Demo video]
    B --> D[Screenshot gallery]
    B --> E[GitHub README]
    B --> F[Live demo site]
    F --> G[Pipeline status]
    F --> H[Product-style results]
    F --> I[Runbook commands]

The first screen of the demo shows the product itself: stage readiness, metrics, and result artifacts. It is not just a marketing landing page.

System Architecture

flowchart TB
    subgraph Inputs
        V[Animation footage]
        C[Project YAML/TOML configs]
        M[Local model warehouse]
    end

    subgraph Pipeline_Core[Python pipeline core]
        O[Stage orchestrator]
        R[Resource monitor]
        S[Stage manager]
        IO[Metadata IO]
    end

    subgraph CV_Stages[Computer vision stages]
        F[Frame extraction]
        D[Detection and tracking]
        G[Segmentation and matting]
        P[Pose extraction]
        E[Embedding index]
    end

    subgraph Training_Stages[Training and evaluation stages]
        LD[LoRA dataset builder]
        CD[ControlNet dataset builder]
        T[LoRA / ControlNet training adapters]
        Q[Evaluation and sample generation]
    end

    subgraph Demo_Layer[Public demo layer]
        Stub[CPU-safe stub artifacts]
        Manifest[Static manifest JSON]
        Site[portfolio-web static site]
        Media[Screenshots and video]
    end

    V --> F
    C --> O
    M --> D
    O --> R
    O --> S
    S --> IO
    F --> D --> G --> P --> E --> LD --> CD --> T --> Q
    IO --> Manifest
    Stub --> Manifest
    Manifest --> Site
    Media --> Site

Data Contracts

flowchart LR
    Frames[frames.parquet] --> Detections[detections.parquet]
    Detections --> Foreground[fg.parquet + RGBA cutouts]
    Foreground --> Pose[poses.parquet + pose images]
    Foreground --> Embeddings[embeddings.parquet]
    Pose --> ControlNet[controlnet metadata]
    Embeddings --> LoRA[LoRA dataset metadata]
    LoRA --> Samples[inference sample metadata]
    ControlNet --> Samples
    Samples --> Animation[animation frames metadata]
    Animation --> Manifest[portfolio manifest JSON]

Each stage produces inspectable metadata. The public demo reads the final manifest and renders the same stage model in the browser.

Pipeline Stage Matrix

Repository Map

.
|-- anime_pipeline/          Packaged 2D/3D pipeline library
|-- scripts/
|   |-- core/pipeline/       Main staged orchestrator CLI
|   |-- demo/                Demo manifest and public asset generator
|   |-- generic/             Reusable video, segmentation, clustering, quality, training tools
|   |-- batch/               Long-running generation/training automation
|   |-- training/            Training launchers, monitoring, checkpoint evaluation
|   `-- monitoring/          Progress and health scripts
|-- configs/                 Global, stage, project, batch, training, and evaluation configs
|-- portfolio-web/           Public static demo website
|-- docker/                  Nginx static hosting package
|-- tests/                   Demo-safe smoke tests and focused pytest suites
|-- requirements/            Modular dependency sets
`-- .github/workflows/       GitHub Pages demo deployment workflow

Frontend, Backend, Data, API, Deployment

Demo Scenarios

Local Demo Commands

Install only the demo-safe dependencies:

pip install -r requirements/core.txt -r requirements/dev.txt

Refresh the manifest from existing CPU-safe outputs:

python scripts/demo/run_demo_pipeline.py --skip-pipeline

Run the complete stub pipeline first, then refresh the manifest:

bash bash/run_full_pipeline_stub.sh
python scripts/demo/run_demo_pipeline.py --skip-pipeline

Serve the static demo:

python -m http.server 8080 -d portfolio-web

Build and serve through Docker:

docker build -f docker/portfolio.Dockerfile -t 3d-animation-lora-pipeline-demo .
docker run --rm -p 8080:80 3d-animation-lora-pipeline-demo

Testing and Verification

Full python -m pytest tests/ can require GPU/model dependency alignment because several tests touch heavy diffusers, inpainting, training, or local model paths.

Real Model Workflow

Real model runs are workstation jobs, not hosted website jobs.

pip install -r requirements/all.txt
bash scripts/setup/install_pipeline_dependencies.sh
python -m scripts.core.pipeline validate --project <project_id>
python -m scripts.core.pipeline run --project <project_id> --device cuda

Common requirements:

Deployment Architecture

flowchart LR
    Dev[Local repo] --> Commit[Commit demo assets]
    Commit --> Main[origin/main]
    Main --> Action[Deploy Demo Site workflow]
    Action --> GH[gh-pages branch]
    GH --> Pages[GitHub Pages]
    Pages --> Public[Public demo URL]

    Commit --> Docker[Docker/Nginx image]
    Docker --> Local[Local static preview]

The ML pipeline does not run on GitHub Pages. Pages only hosts portfolio-web/, static screenshots, demo video, and the generated manifest.

Current Status

Known Risks and Limits

Interview Highlights

Reviewers should focus on:

• File-based ML data contracts through parquet/JSON manifests.
• Config-driven orchestration rather than hard-coded one-off scripts.
• Clear separation between real GPU workflows and CPU-safe public demo mode.
• Public demo assets that are safe to screenshot, record, and publish.
• Docker and GitHub Pages deployment packaging for a static technical showcase.
• Main portfolio integration with cover, gallery, video, demo link, GitHub, and README.

Privacy and Data Notes

Raw media, model weights, generated datasets, checkpoints, logs, and secrets are intentionally excluded from git. Public assets in portfolio-web/ are synthetic/anonymized demonstration files intended for portfolio review.