Visual machine learning
Build a machine learning pipeline by wiring nodes on a canvas. Press Run and a real Python engine trains it, evaluates it, and saves the whole thing as an experiment you can reproduce.
Note The installer is not code-signed yet. Windows SmartScreen may warn you: choose More info, then Run anyway.
01 CAPABILITIES
Seven things the app does between a file on disk and a result you can defend.
Nodes carry data, preprocessing, representation, split, and model. A wire is only allowed if the pipeline would actually run, and a refused wire names the rule it broke and what to insert instead.
Press Run and a real Python engine trains and evaluates the workflow you drew. Nothing on the canvas is simulated.
Training curves draw themselves while the run is in flight, alongside live CPU and GPU usage. You watch the fit converge instead of reading a log afterward.
Classification returns a confusion matrix with ROC and PR curves. Regression returns parity plots. Feature importance appears wherever the model reports it.
Each run is saved as a reproducible experiment, settings included. Runs collect on a leaderboard where they are compared side by side.
The chemistry plugin adds RDKit, SMILES structure drawing, and scaffold splits. Graph neural networks read a molecule as a graph of atoms and bonds rather than a row of numbers.
Plugins add nodes and capabilities to the canvas. The chemistry set is one of them, so what a pipeline can hold is not fixed at install.
SCREENSHOT · RESULTS
02 Model library
Nine model types ship with the app, and they train on plain tables, the built-in datasets, or molecules.
09 entries
File formats
Built-in datasets
The chemistry plugin adds RDKit. Give it a SMILES string and the structure is drawn beside the table it came from.
Splits can be taken by scaffold, so a framework does not sit on both sides of the line. Graph neural networks read the molecule as a graph of atoms and bonds instead of a row of numbers.
SCREENSHOT · MOLECULE
03 THE CANVAS
You build a run by wiring nodes on a canvas, left to right, until the pipeline is complete. A wire that could not execute is refused as you draw it, and the canvas says which rule stopped it.
REFUSALS
Drag a wire the pipeline could not execute and the canvas keeps it from connecting. The inspector names the two nodes, states the rule that blocked them, and says what belongs in between.
The rule is written in plain words, so the next attempt is an informed one rather than a guess.
Every refusal names the rule and the node that would fix it.
FIG CANVAS AND LIVE RUN
SCREENSHOT · CANVAS
SCREENSHOT · LIVE RUN
04 Operation
Every project runs the same short loop: wire the pipeline, run it, then compare what came back.
Drag nodes onto the canvas and wire them: data, preprocessing, representation, split, model. The canvas refuses any wire that would not run, and tells you why.
Nodes / Wires / Validation
Press Run. A real Python engine trains and evaluates the pipeline while training curves and CPU/GPU usage update live.
Python engine / Live telemetry
Each run is filed as a reproducible experiment. Compare them on the leaderboard, and take any workflow out as a Python script or Jupyter notebook.
Experiments / Leaderboard / Export
05 Portability
Runs stay reproducible inside the app, and every workflow leaves it as plain code that runs on its own.
Every run is saved as a reproducible experiment: the workflow, the data configuration and the results travel together, so a number can always be traced back to the pipeline that produced it. Runs are collected on a leaderboard and compared side by side.
| Run | Model | Split | Metric |
|---|---|---|---|
| RUN-011 | KNN | 80-20 | 0.804 |
| RUN-012 | SVM | 80-20 | 0.837 |
| RUN-013 | LightGBM | 70-30 | 0.874 |
| Best run. RUN-014 | XGBoost | 80-20 | 0.891 |
| RUN-015 | Random forest | 80-20 | 0.866 |
+ marks the best run · figures are illustrative
SCREENSHOT · LEADERBOARD
Any workflow exports to a plain Python script or a Jupyter notebook. The file is ordinary pandas, scikit-learn and XGBoost, and it runs on its own, without AI Maestro installed.
# Exported from AI Maestro 0.1.0 - workflow: titanic-xgb
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
# data
df = pd.read_csv("data/titanic.csv")
y = df["survived"]
X = df.drop(columns=["survived"])
X = pd.get_dummies(X, drop_first=True)
X = X.fillna(X.median())
# split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y)
# model
model = XGBClassifier(
n_estimators=300, max_depth=4, learning_rate=0.08
)
model.fit(X_train, y_train)
# evaluate
preds = model.predict(X_test)
acc = accuracy_score(y_test, preds)
print("accuracy:", round(acc, 3))Export includes the pipeline, the parameters and the split.
06 SPECIFICATION
Everything AI Maestro needs to run on a Windows desktop.
AIMaestro-Setup.exe · AIMaestro-Setup-CUDA.exeAIMaestro-Setup.exe is not code-signed yet, so Windows SmartScreen may show a blue “Windows protected your PC” dialog the first time you run it. Click More info, then Run anyway.
Code signing is planned.
07 QUERIES
What the installer warns about, what runs where, and what the app can read.
The installer is not code-signed yet, so Windows SmartScreen may show “Windows protected your PC” the first time you run it. Choose More info, then Run anyway. Signing is planned.
No. You build the pipeline by wiring nodes on the canvas. If you want the code, export the workflow as a plain Python script or a Jupyter notebook.
No. The app ships with its own Python engine, and Run uses it. You do not need a separate Python installation.
AI Maestro is a desktop application. It reads the files you point it at and runs the training on your machine.
CSV, Parquet, JSON and Excel files. Five datasets are built in: Iris, Titanic, California Housing, ESOL and Tox21.
XGBoost, LightGBM, random forest, SVM, KNN, linear and logistic regression, a PyTorch MLP, and graph neural networks for molecules. Each one is a node you drop on the canvas.
Yes, with the CUDA build: it ships a CUDA PyTorch and trains the MLP and the graph neural networks on an NVIDIA GPU (driver 570 or newer). The standard build ships the CPU PyTorch and trains the same models on the CPU. Both show CPU and GPU usage live during a run.
Because the resulting pipeline would not run. The canvas names the rule and the node that would fix it. Most often that is a missing Split before the model.
No. This 0.1.0 build is for Windows 10 and 11, 64-bit, and the download on this page is that installer.
Yes, through plugins. The chemistry plugin is built that way: RDKit, SMILES structure drawing and scaffold splits.
08 ACQUISITION
Two installers for 64-bit Windows 10 and 11, version 0.1.0. The standard build trains on the CPU; the CUDA build uses an NVIDIA GPU for the PyTorch MLP and the graph neural networks. Everything else is identical, and both carry every runtime the node library needs.
Install sequence
01
Save AIMaestro-Setup.exe, or AIMaestro-Setup-CUDA.exe for an NVIDIA GPU, and open it.
02
Windows may show “Windows protected your PC”. Click More info.
03
Choose Run anyway and the installer continues.
AIMaestro-Setup.exe is not code-signed yet, which is why Windows raises the prompt above. Code signing is planned.