AIMLSE Documentation

Everything you need to build, experiment, and collaborate inside the Adaptive Coding Interface — from first template to production-ready PyTorch.

What is AIMLSE?

AIMLSE is an AI/ML development platform built around one principle: move fast and stay in control. Its centrepiece is the Adaptive Coding Interface (ACI) — a four-layer environment that adapts to how you naturally think, from high-level template selection down to raw Python execution.

Quickstart

Once accepted into the beta, getting your first project running takes under five minutes.

1. 1
   Submit your application

   Fill out the beta application form on the main page. Selected applicants receive an invite link via email along with the NDA to sign.
2. 2
   Create your first project

   Hit + New Project and enter a brief objective. The Template Recommendation Engine (F0) surfaces three to five verified project structures matched to your goal.
3. 3
   Select a template

   The environment initialises with a pre-organised folder structure, base imports, and scaffolding — all verified PyTorch, no hallucinated dependencies.
4. 4
   Build using whichever layer suits you

   Switch between F1, F2, and F3 at any point. Your context — variables, imports, helper functions — follows you across all layers.
5. 5
   Contribute back to the library

   If you write a helper function worth sharing, submit it to the community library for review and attribution.

# Training loop scaffold from a verified F0 template
import torch
from aimlse.helpers import EarlyStopping, MetricTracker

tracker = MetricTracker(metrics=['loss', 'accuracy'])
stopper = EarlyStopping(patience=5, delta=1e-4)

def train_epoch(model, loader, optimizer, criterion, device):
    model.train()
    for data, target in loader:
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        loss = criterion(model(data), target)
        loss.backward()
        optimizer.step()
        tracker.update('loss', loss.item())
    return tracker.epoch_summary()

Requirements & Access

AIMLSE is currently invite-only during Phase 1 beta. Access is granted after submitting an application and selection by the team.

Preferred Background

System Requirements

What is the ACI?

A unified workspace where four distinct interaction layers coexist in a single project. You decide which layer to use at any moment, and context follows you every time you switch.

F0 — Template Recommendation Engine

Describe your project objective. The engine surfaces verified project structures assembled by experienced ML practitioners — not generated by an AI. Templates include pre-organised folder structures, base PyTorch imports, and scaffolding.

my-classification-project/
├── data/
│   ├── raw/  └── processed/
├── models/
│   └── backbone.py        # Verified ResNet/ViT scaffold
├── training/
│   ├── train.py           # Training loop (from F1 library)
│   └── losses.py
├── utils/
│   ├── metrics.py         # MetricTracker helper
│   └── early_stopping.py
└── config.yaml

F1 — Helper Function Recommendation Engine

The engine reads your context in real time and surfaces relevant, reusable PyTorch helpers from the community library. Every function has been reviewed, tested, and verified before inclusion.

from aimlse.helpers import (
    WarmupCosineScheduler,
    LabelSmoothingLoss,
    GradientClipper,
    CheckpointManager
)

scheduler = WarmupCosineScheduler(optimizer, warmup_steps=500, total_steps=10000)
loss_fn   = LabelSmoothingLoss(smoothing=0.1)
clipper   = GradientClipper(max_norm=1.0)
ckpt      = CheckpointManager(path='./checkpoints')

F2 — Block-Based Coding System

Visually assemble your ML pipeline before writing a single line. Drag blocks for training loops, data loaders, model architectures, loss functions, and evaluation hooks into place — the system compiles the result into real, executable PyTorch.

F3 — Script / Notebook Layer

Full notebook environment: raw Python execution, inline outputs, iterative experimentation — plus complete awareness of your project context from every layer above.

What's different from Jupyter: your F0 template's imports are pre-loaded, F1 helpers are immediately available via from aimlse.helpers import ..., F2 block variables carry over into the kernel, and collaborators see your changes in real time.

Layer Interoperability

The four layers are designed to be used together fluidly. Move between them at any point — context follows you every time.

New-to-familiar: F0 template → F1 utilities → F2 pipeline sketch → F3 iteration. Recommended for new projects.

Architect-first: Jump to F2, assemble visually, export to F3 for execution and debugging.

Expert mode: Open F3 directly. Template structure and library imports already present; use F1 recommendations as a sidebar reference.

Live Collaboration

Real-time collaboration built for the research lab model — multiple engineers on the same experiment simultaneously, not asynchronously through version control.

PyTorch Integration

AIMLSE is built exclusively around PyTorch — a deliberate commitment to one ecosystem that enables deep, verified integration at every layer. All platform components target PyTorch 2.0+.

Supporting multiple frameworks would make it impossible to guarantee every library component is correct. AIMLSE chose depth over breadth.

class LabelSmoothingLoss(nn.Module):
    """Verified: PyTorch 2.0+, tested on CUDA 11.8 and 12.1."""
    def __init__(self, smoothing: float = 0.1):
        super().__init__()
        self.smoothing = smoothing

    def forward(self, pred, target):
        n = pred.size(-1)
        log_p = nn.functional.log_softmax(pred, dim=-1)
        with torch.no_grad():
            t = torch.full_like(log_p, self.smoothing / (n - 1))
            t.scatter_(-1, target.unsqueeze(-1), 1.0 - self.smoothing)
        return (-t * log_p).sum(dim=-1).mean()

Beta Access

Phase 1 beta opens July 12 at 7:30 PM CST. Twenty engineers receive full platform access at launch.

Phase Roadmap

Frequently Asked Questions