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 layer, 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.
3. Build with visual blocks or drop straight into the notebook.
4. Run it on a GPU with your private-beta tokens (see GPU tokens).

Your free tier

Every account includes:

• All five layers, with none of them 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: five layers

The ACI is a dial. You choose how much help you get, and you can turn the dial at any time without losing a line of code.

• 01Templates: verified project structures that run on first launch.
• 02Helper functions: ranked, verified PyTorch helpers.
• 03Blocks: visual pipelines that compile to real PyTorch.
• 04Data: your files, living inside the project.
• 05Notebook: full cell-based control, no help at all.

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.

Helper functions

The Library surfaces ranked 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.

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.

The core palette is color-coded by category (data, preprocessing, model, training, evaluation, math, utility, control) and filterable with a category dropdown, so its 178 blocks stay easy to scan instead of one long alphabetical list. Every block carries a one-line AI-written summary, visible on hover; click its ✨ icon to ask Aimlse Bot about that specific block instead of getting redirected to external PyTorch documentation.

Need more than the core palette? Open 📦 Libraries in the palette header to install additional block libraries, NumPy, pandas, scikit-learn, Matplotlib, and more, each with thousands of AI-summarized blocks pulled straight from the real package.

# 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),
)

Data

Every project has a Files tab. Drop in a CSV, an Excel sheet, a .py module, or any data file and it lands in the project's data/ folder, readable from blocks and code alike, e.g. pd.read_csv('data/<file>'). Folders keep larger datasets organized, and everything travels with the project.

Notebook

When you want full manual control, drop into the cell-based notebook. It's the same project you started from a template, 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 layers 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.

Using a GPU

GPU compute is pay-as-you-go, not a fixed-hours rental: pick a model from the picker, start a session, and it bills for exactly what elapses. No upfront duration to guess. You'll get a warning at 60, 30, 10, 5, and 1 minute of remaining balance; if it runs out, the session ends on its own and switches to CPU rather than just cutting off.

# 1. see what's available and pick a model
GET /user/tokens/gpus-available
→ { "available_gpus": [{ "gpu_type": "RTX 3070", "tokens_per_hour": 8, ... }, ...] }

# 2. start a session on it
POST /user/tokens/session/start
{ "gpu_type": "RTX 3070" }
→ { "active": true, "mode": "gpu", "remaining_tokens": 300, "remaining_minutes": 2250 }

# 3. poll every ~20s while it's running
GET /user/tokens/session/status
→ { "active": true, "remaining_minutes": 2231, "warning_threshold_min": null }

# 4. stop whenever you're done
POST /user/tokens/session/stop
→ { "active": false, "mode": "cpu" }

Bring your own GPU

Already have a GPU, a workstation, a home rig, a lab machine? Register it as an alternative to the marketplace GPU. Running on your own hardware never spends your tokens; it's a separate path from the token ledger entirely.

POST /user/gpu/register
{ "label": "My home 4090", "host": "100.x.x.x:8080" }
→ registered. GET /user/gpu/mine to fetch it, DELETE /user/gpu/mine to remove it.

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 layers they can access. Live collaboration is a Pro feature.

Aimlse Bot

Aimlse Bot, powered by DeepSeek, is a project-aware assistant available from every project. It can see what you're currently working on, so its answers are grounded in your actual code rather than generic advice. Open it from the ✨ Aimlse Bot button in the editor toolbar, or ask about a specific block directly from its ✨ icon in the palette.

It follows the same no-hallucination principle as the rest of AIMLSE: if it isn't sure a PyTorch API behaves the way it's about to describe, it says so instead of guessing. Replies are kept concise by design, capped to a focused answer rather than an open-ended essay.

POST /api/v1/aimlse-bot/chat
{ "message": "Why is my Conv2d shape mismatched?", "project_context": { "active_view": "f2-view" } }
→ { "reply": "…" }

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.