FrameTrain screenshots: what local ML training looks like
No mockups, and no video that loops back to the start after two minutes. The screenshots below show the desktop app as it runs on your machine – from importing a HuggingFace model through training configuration to loss curves and model versions. Each section explains what the panel does and where it sits in the workflow.
All screenshots come from the English interface. The app is fully bilingual – switch the language to see the same panels in German.
01
Model management – HuggingFace and local models in one place
The model overview lists everything FrameTrain knows about: models imported from HuggingFace, weights stored locally, and networks you built yourself in the Synapse Builder. Each card shows file count, size on disk, storage path and the plugin responsible for that model. Models without a matching plugin are flagged up front instead of failing once training starts.
Model overview: TinyLlama, xlm-roberta, YOLO and custom canvas networks side by side, with size, date and the plugin in charge.
Import from HuggingFace by repo ID
Size, file count and storage path per model
Plugin detection for XLM-RoBERTa, YOLO, Llama and more
02
Datasets – Parquet, flat files and splits
Datasets belong to a model: the selector at the top filters the list down to what fits the model you picked. FrameTrain reads multi-shard Parquet natively, shows file size and modification date, and flags whether a train/val/test split already exists. If one is missing, you split the dataset right in the app – halving included.
Datasets per model, with format, size and split status. “No split” is a hint, not an error – splitting happens right here.
Multi-shard Parquet supported natively
Train/val/test split without touching the command line
Compatibility check against the selected model
03
Configure training – hyperparameters, LoRA and QLoRA
The training screen puts model, version and dataset side by side and checks up front whether the plugin supports that combination. Base parameters are open by default: epochs, batch size, learning rate, max sequence length, warmup ratio and gradient accumulation. Optimizer & scheduler, advanced & evaluation, and LoRA / QLoRA expand when you need them. Mixed precision switches per backend – FP16 stays locked where the hardware wants BF16.
Training configuration for xlm-roberta-base: base parameters open, optimizer, evaluation and LoRA/QLoRA one level down.
LoRA and QLoRA as their own configuration section
Templates and the AI assistant supply sane starting values
FP16 and BF16 mixed precision depending on hardware
The history collects every run with status, duration, model and dataset used, filterable by running, successful, failed and stopped. Months later you can still tell which dataset produced which result – the question experiments without a log keep failing on.
Training history with status filters. The dataset used is attached to every entry.
Filter by running, successful, failed and stopped
Dataset and model logged per run
Timestamp and runtime at a glance
05
AI training analysis – metrics in plain language
FrameTrain sends a run's metrics to a language model of your choice and gets back an assessment in plain language: what went wrong, which measures help, and which parameters the next run should start with. The parameter suggestion arrives as a JSON block you can save as a training template in one click.
AI training analysis for a specific model version: diagnosis, recommended parameters, forecast.
An assessment in prose instead of raw number series
Parameter suggestions can be saved as a training template
AI coach – follow-up questions in the panel's context
The AI coach is a chat that knows which panel you are standing in. Ask it how to improve validation loss for this run and it answers against the values actually loaded rather than in generalities – learning rate, dropout, weight decay, LoRA capacity. Concrete suggestions can be applied without retyping fields by hand.
The coach sits on top of the panel it draws its context from – here the training panel.
Context taken from the panel currently open
Suggestions can be applied straight into the fields
You decide which language model sits behind analysis and coach: Claude, GPT-4o and Groq run on your own API key, Ollama runs fully locally without one. If you want no AI features at all, switch the assistant off globally. Training itself is independent of this and always runs on your hardware.
Provider choice for the AI features. Ollama runs locally and needs no API key.
Ollama locally, no API key and no data leaving the machine
A training run overwrites nothing; it creates a new version. The version list shows train loss, validation loss, epochs, size and storage path per state, and the imported original stays untouched. Rolling back means selecting the older version.
Four states of the same model. Train and validation loss per version show which run actually helped.
The imported original is always preserved
Metrics and size per version
The storage path of every version is visible
09
Laboratory – test trained models on real samples
In the laboratory you load individual samples from train, val or test and let the trained version answer them: pick test engine or dev script, load the model for inference, load samples, start the session. A loss value alone simply does not answer whether a model is useful in practice.
Laboratory configuration: version, engine and sample selection before the session starts.
Samples pulled specifically from train, val or test
Train engine or your own dev script
Sessions are kept for comparison
10Beta
Synapse Builder – architecture as a graph
The Synapse Builder assembles networks from nodes: input, CSV, image and Parquet loaders, tokenizer, dataset split, augmentation, plus dense, Conv2D, embedding, LSTM, attention, transformer block, LayerNorm, BatchNorm and dropout. The training bar at the bottom carries epochs, batch size, learning rate, GPU, precision and grad accum – runs start from the same window.
Synapse Builder with 27 nodes and 25 connections. The training bar at the bottom starts the run straight from the canvas.
Node library for data, layers and activations
Start training directly from the canvas
Architecture can be exported
Try it yourself
FrameTrain runs on Windows, macOS and Linux and trains entirely on your own hardware. No cloud, and no data leaving your network.
