How pupipatsk/nanollada works
Project Type and Purpose
• This is an NLP research and fine‐tuning project built around LLaDA (Large Language Diffusion with Masking).
• It combines data pipelines, model training & evaluation scripts, serverless inference via Modal, Jupyter notebooks for experimentation, and a Next.js-based frontend for demoing or visualizing results.
Main Components
A. Data Layer
– Raw dataset (Huggingface “nakhun/thaisum” CSV files in /data).
– Pre‐processing utilities (src/utils/csv_to_parquet.py).
– Versioned score & report files under /data/score and /data/report.
B. Training & Fine-Tuning Pipeline
– Modal jobs for fine-tuning (modal/fine_tune.py).
– Model checkpoints and logs (implicitly managed by Modal).
– Poetry–managed environment (pyproject.toml, .venv/).
C. Inference & Evaluation
– Base‐model inference (modal/inference-base.py) and fine‐tuned inference (modal/inference.py).
– Evaluation scripts under /eval (2025-05-08-eval-parallel.py, summarize_evals.py).
D. Experimentation Notebooks
– Various Jupyter notebooks in /notebooks used for POC, evaluation, refactoring.
E. Web Frontend
– Next.js 13 app in /web with React/TypeScript components (/web/app, /web/components, /web/hooks, /web/lib).
– Styling via Tailwind (tailwind.config.ts), global CSS.
– Entry point (web/app/page.tsx), layout, theme provider, and summarizer utility (web/lib/summarizer.ts).
F. External Services
– Huggingface Dataset API (for downloading “thaisum”).
– Modal Cloud (serverless compute).
– Optional: GitHub Actions or local scheduler (not explicitly shown but implied for CI).
Relationships & Data Flows
• From Modal Fine‐tune → Model artifacts → Modal Inference → Generated summaries.
• From Generated summaries → Evaluation scripts → Score outputs in /data/score.
• Web Frontend calls a REST or RPC endpoint (hosted via Modal inference) to fetch summaries; renders via React components.
• Jupyter notebooks connect to the same Poetry virtual env and may trigger local versions of training/inference or pull results from /data.
Architectural Patterns & Design Principles
• Separation of Concerns:
– Data ingestion/pre‐processing, training, inference, evaluation, and presentation are distinct layers.
• Serverless Compute:
– Modal functions decouple compute and orchestration.
• Modular Code Organization:
– Python modules (src/utils) vs. JS/TS modules (web/components, web/lib).
• Experimentation vs. Production Paths:
– Notebooks for R&D, Modal scripts for reproducible runs, Web app for consumer‐facing demos.