Back to Projects
Flagship case studyreview surface

Neuromosaic

ML infrastructure that automates neural architecture search. LLM-powered code generation (GPT-4, LLaMA, vLLM), real-time Dash/Plotly monitoring via WebSocket, and a 22-table PostgreSQL backend managed by FastAPI. 521 commits, 44.7K LOC.

Distributed MLInfrastructureFastAPIPyTorchLLM Code Gen
Neuromosaic

Build surface

The implementation surface for this system. These are the layers that mattered in practice, not a generic skills wall.
Backend
FastAPI, SQLAlchemy, Alembic
Database
PostgreSQL, SQLite, 22 Tables
ML/AI
PyTorch, Transformers, LLM Code Generation (GPT-4, LLaMA, vLLM)
Monitoring
WebSocket, Dash/Plotly Dashboard
Cloud
HuggingFace Hub
API
21 Endpoint Modules, RESTful
Quality
Pytest, Coverage, Pre-commit

The Problem

ML researchers waste weeks on manual architecture experimentation with no infrastructure for systematic exploration. Each variation requires hand-coding, manual deployment, and ad-hoc tracking — limiting the search space and making results irreproducible.

  • No orchestration: Each experiment runs manually with custom scripts and no resource management
  • Limited exploration: Human bias constrains architecture search to familiar patterns
  • Poor reproducibility: No systematic tracking of code, environment, and configuration across experiments
  • Resource waste: No visibility into compute utilization across experiments

Infrastructure Architecture

Experiment Pipeline

End-to-end infrastructure from architecture vector encoding to training runs, with meta-learning feedback loop and real-time WebSocket monitoring.

01

Experiment Orchestration

FastAPI-based infrastructure for running, tracking, and managing ML experiments with a 22-table PostgreSQL backend

  • FastAPI backend with 21 endpoint modules managing experiments, architectures, and results
  • PostgreSQL database with 22 tables handling the full experiment lifecycle
  • Environment pinning and versioning for reproducible experiment runs
  • LLM-driven architecture generation reducing manual coding of model variants
02

LLM-Powered Architecture Generation

Automated neural architecture search using LLM code generation and meta-learning optimization

  • Compositional encoding: vector representation of neural architectures with 50+ component types
  • GPT-4 and local LLaMA models generate PyTorch code directly from architecture vectors
  • Meta-learning loop: Bayesian optimization and evolutionary search guide architecture selection
  • Complete versioning of generated code, environments, and results for full reproducibility

Monitoring & API Infrastructure

01

Real-Time Experiment Monitoring

WebSocket-powered monitoring infrastructure for ML experiments

  • Live training metrics streamed via WebSocket to interactive Dash/Plotly dashboard
  • Dash/Plotly visualization with experiments color-coded by performance
  • Cluster analysis automatically groups similar architectures and identifies patterns
  • Resource monitoring tracks compute utilization during experiment runs
02

SDK & API Layer

Comprehensive API infrastructure for programmatic access to the experiment platform

  • RESTful API with 21 endpoint modules and full OpenAPI documentation
  • SDKs in Python and TypeScript for integration into existing ML workflows
  • Type-safe data layer with Pydantic/SQLModel for experiment configuration and results
  • Database migrations with Alembic for schema evolution without data loss

Infrastructure Metrics

Commits
521
Active development
API Endpoint Modules
21
Full experiment management
Database Tables
22
Complete experiment lifecycle
Lines of Code
44.7K
Python + TypeScript

Why Environment-Versioned Experiment Isolation

Each experiment pins its dependencies and stores generated code alongside results in PostgreSQL. This guarantees reproducibility — any experiment can be re-run months later with identical environment and configuration, without relying on containerization infrastructure.

Why LLM Code Generation Over Configuration Files

Configuration-based NAS systems are limited to predefined building blocks. LLM code generation can produce novel architectural patterns that wouldn't exist in a predefined search space. The meta-learning loop then evaluates these novel architectures and feeds results back to guide future generation.

Next inspection step

Inspect the system further

Use the live surface or the source as the next level of proof. The goal here is not to end on a marketing flourish, but to make the next inspection step obvious.

Source
https://github.com/hopeatina/neuromosaic
Why this matters
Strong systems work should be inspectable from multiple angles: interface, architecture, and implementation.