Build PyTorch with AIMLSE

Overview

Most ML prototyping is a relay race between a template repo, a notebook, a folder of helper snippets, and a deployment tool. AIMLSE collapses that into a single adaptive interface. You pick a starting fidelity, from fully guided templates to a raw notebook, and every layer shares the same project and the same canonical code.

The guiding principle is sub-autonomy: AIMLSE accelerates you without ever inventing code. Suggestions are grounded in a verified library, and visual blocks compile to PyTorch you can read. You stay the author.

Quickstart

1. Create an account on the home page with email, password, or Google. You'll receive an aml-… AIMLSE ID, your permanent developer identity.
2. Open the Project Library and start a new project from a verified template (F0).
3. Build with visual blocks (F2) or drop straight into the notebook (F3).
4. Run it on a GPU with your private-beta tokens (see GPU tokens).

Your free tier

Every account includes:

• Full F0 to F3 access, with no layer paywalled.
• GPU compute for running models on a real GPU, with 300 tokens for private-beta members (see GPU tokens).
• 5 GB of storage and 30 grounded AI prompts per month.
• The templates and community helper library.

Pro ($15/mo) adds the App Builder, GitHub export, live collaboration, and external deployment.

The ACI: four fidelities

The ACI is a ladder. The lower rungs are more guided; the higher rungs give you more raw control. You can switch rungs at any time without losing a line of code.

• F0Templates: verified project structures that run on first launch.
• F1Library: curated, verified helper functions.
• F2Blocks: visual pipelines that compile to real PyTorch.
• F3Script: a full cell-based notebook for total control.

F0 · Templates

Templates are complete, verified project structures, covering the model definition, training loop, and data pipeline, that execute the moment you open them. They remove the setup tax so your first edit is a real change, not boilerplate. Templates are recommended to you based on what you're building.

F1 · Library

The Library surfaces curated PyTorch helper functions drawn from your own projects and the public community library. Every function is verified before it can be recommended, so nothing unverified ever enters your workspace. Pull a helper in with one click and it arrives as readable code.

F2 · Blocks

Blocks let you assemble a model visually. Drag layers onto the canvas to think structurally, then read the generated code to be certain of what runs, since every block compiles to real, inspectable PyTorch.

# Conv2d → BatchNorm → ReLU → Linear  compiles to:
import torch.nn as nn

model = nn.Sequential(
    nn.Conv2d(3, 64, 3),
    nn.BatchNorm2d(64),
    nn.ReLU(),
    nn.Linear(64, 10),
)

F3 · Script

When you want full manual control, drop into the cell-based notebook. It's the same project you started in F0, and your blocks and helpers are already there as code. Run cells, inspect tensors, and iterate exactly as you would in any notebook, with the rest of the ACI a tab away.

No hallucinated code

AIMLSE is built so that assistance never fabricates APIs:

• Grounded suggestions: helpers come from the verified library, not a model's guess.
• What you see is what runs: blocks compile to PyTorch you can diff and edit.
• You stay the author: the assistant explains, refactors, and flags inefficiencies. It doesn't take the wheel.
• One source of truth: moving across fidelities never forks your code.

GPU tokens

Running a model needs a GPU. GPU compute is rolling out through our private beta: beta members get 300 GPU tokens to spend on real compute, and we're opening it to everyone in stages. Tokens, not dollars, are the unit you see and spend.

Tokens are pegged to a fixed value, but the GPU's market price floats. So the cost per hour, in tokens, moves with the live rate: when the GPU is cheap an hour costs fewer tokens; when it's in demand, more. Your 300 tokens therefore buy more or fewer hours over time.

Renting a GPU

Reserve the GPU for a number of hours; tokens are deducted at the live rate.

# 1. check the live rate
GET /user/tokens/rate
→ { "tokens_per_hour": 8, "hours_for_full_allowance": 37.5 }

# 2. reserve 2 hours
POST /user/tokens/use
{ "user_id": "…", "gpu_type": "RTX 3070", "duration_hours": 2 }
→ { "tokens_used": 16, "new_balance": 284 }

Collaboration

Prototyping is rarely solo. AIMLSE projects support real-time collaboration:

• Live cursors: see where teammates are working as they work.
• Shared editing: edit the same project at the same time, without stepping on each other.
• Version sync: snapshots and a shared operation log keep everyone aligned.

Invite collaborators by email from the Users panel. Each invite carries per-user permissions, including which fidelities (F0 to F3) they can access. Live collaboration is a Pro feature.

API overview

AIMLSE exposes a REST API. Authenticate by sending your access token as a bearer header:

Authorization: Bearer <access_token>

You receive an access token and refresh token on login. Tokens for a given user can only be read or spent by that user (or an admin).

Auth endpoints

Token endpoints

Support

Questions, bug reports, or enterprise enquiries, reach the team at info@aimlse.org. We read everything.