Skyulf
PRODUCTS
Kayra
Draw it. Code it. Ship it. Kayra keeps scikit-learn as the engine and adds what notebooks never gave you: reproducible artifacts, honest validation scores, and a path to production.
Runs in your browser, no signup.
Hospitals, banks and public bodies run Kayra on their own servers. Nothing is uploaded, nothing is billed per prediction.
Keep scikit-learn, get leakage checks, versioned runs, a model registry and a REST endpoint, and export back to a notebook any time.
Start locally, then generate a Databricks bundle with training, scoring, monitoring and serving jobs on Unity Catalog.
Prefer clicking or typing? Both produce the same kind of pipeline, and the canvas exports to a notebook whenever you want to drop back into code.
The full application: a node canvas, automated EDA, background training, experiment comparison, a model registry, deployment and monitoring, all running on your own machine or server.
$ git clone https://github.com/flyingriverhorse/Kayra $ docker compose up
No server, no UI, no lock-in. A pip-installable library that gives your scripts and notebooks one consistent pipeline API over scikit-learn, with the leakage checks and artifacts built in.
# Runs as-is: the dataset ships with scikit-learn.
from sklearn.datasets import load_breast_cancer
from skyulf import SkyulfPipeline
df = load_breast_cancer(as_frame=True).frame
# The configuration is a dict, so you can version it, diff it in
# review, or build it in a loop.
pipeline = SkyulfPipeline({
"preprocessing": [
{"name": "split", "transformer": "TrainTestSplitter"},
{"name": "impute", "transformer": "SimpleImputer"},
{"name": "scale", "transformer": "StandardScaler"},
],
"modeling": {"type": "random_forest_classifier"},
})
# Move the imputer above the splitter and it tells you so, by name.
print(pipeline.validate_leakage_safety()) # []
results = pipeline.fit(df, target_column="target")
print(results["modeling"]["splits"]["test"].metrics)
# {'roc_auc': 0.9954, 'f1': 0.9722, 'pr_auc': 0.9972, ...}
pipeline.save("tumour.pkl") # save fitted preprocessing and modelEvery stage lives in one workspace, so nothing gets lost between a notebook, a spreadsheet of results and whatever is actually running in production.
Upload CSV, Excel, JSON or Parquet, or connect an S3-compatible bucket. Kayra reads it with Polars, profiles the columns and keeps every version you load, so you can always tell which data produced which model.
One click profiles every column: distributions, correlations, outliers, interactions and clusters. Surrogate decision trees and causal discovery show which relationships actually drive your target.
Drag nodes onto the canvas and connect them. Branch a pipeline to try two feature strategies side by side, preview any node's output as a table, and let validation block a run before it wastes your time.
Runs execute as background jobs, so a long training run never freezes the UI. Switch on hyperparameter search (grid, random, halving or Optuna) and watch each trial report as it finishes.
Every run keeps its metrics, curves and confusion matrix. Put runs next to each other, see which change actually helped, and tune decision thresholds rather than accepting whatever 0.5 gives you.
Trained models land in a registry with their versions and artifacts. Promote one to active and it is served behind a REST endpoint you can call from anything, or export it as a standalone API and batch project that runs without Kayra. The full deployment history is kept for audit.
Models decay because the world moves. Kayra compares live data against the training baseline column by column and flags what shifted, plus an error log, a slow-node profiler and an audit trail.
Usually nothing is broken. The score was just measured wrong, and nothing in a normal notebook tells you that.
Where these numbers come from: one model, trained twice on the same data. When feature selection peeked at the test rows, the test score said 88% but 5,000 new rows gave 75%. In the correct order, the test score said 72% and the new rows gave 69%, close to the truth. Average of 10 runs. Run the notebook yourself →
Fill missing values, scale a column, encode a category or pick features before you split into train and test, and those steps quietly learn from the test rows. Your validation score now includes answers it was supposed to be guessing. The code runs fine. The number just isn't real.
Kayra reads the order of your steps before anything trains. In the library you get the step, the splitter and the fix by name. On the canvas the run is stopped before it starts.
Walk through it in the leakage notebook →Every node is split into a part that learns and a part that applies. Learning only ever sees training rows, and what it learned is saved as explicit parameters, so scoring new data never refits anything.
During cross-validation and tuning, preprocessing is refit on each fold's training rows only. The held-out fold stays unseen, so a tuning score never includes rows the preprocessing already learned from.
Each pipeline gets a fingerprint and an exportable model card. When someone asks which preprocessing produced a prediction, you answer with a record instead of a guess, and hand over a notebook that re-runs it.
Most visual ML tools stop at the model. Kayra keeps going: drift reports, an error log that links to the failing node, slow-node profiling and an audit trail of every pipeline change.
The same pipeline ships as a Databricks asset bundle with training, feature tables, scoring and monitoring jobs. Models register to Unity Catalog, and drift, performance loss and serving rollouts are watched on the cluster.
Databricks guides →$ databricks bundle init skyulf-core/templates/databricks $ databricks bundle validate --strict -t test $ databricks bundle deploy -t test $ databricks bundle run features -t test $ databricks bundle run train -t test $ databricks bundle run monitoring -t test
Versioned models with their artifacts and history, so you always know what is live.
Download a trained model as a standalone project: an HTTP API and CSV/Parquet batch scoring that run without the Kayra server. Quickstart
Grid, random and halving search built in; Optuna available as an optional extra with live trial output.
Optional explainability extra: see which features moved a prediction, globally or row by row.
Turn any pipeline into a runnable Jupyter notebook, compact or full, including a serving snippet.
Split one canvas into independent paths and run them as parallel jobs to compare approaches.
Voting and stacking for classification and regression, with nested tuning of the base models.
TF-IDF, count and hashing vectorizers, tokenisation, and optional dense sentence embeddings.
Lag and rolling windows, date parts, H3 indexing and distance features for spatial data.
Every pipeline save recorded with what was added, removed or changed, and by whom.
Integration templates for MLflow and Databricks, with more on the way.
Every line below points to the code, notebook or demo that backs it. Nothing here is a roadmap item.
validate_leakage_safety() reads the step order and names any imputer, scaler or encoder that would learn from test rows. The leakage notebook builds a leaking pipeline and shows the warning, then the fix.
Open the notebook ↗Numeric columns get Kolmogorov-Smirnov, Population Stability Index, Wasserstein distance and KL divergence, each with its own threshold. Categorical columns get PSI and the share of unseen categories. A column whose type changed is flagged on its own.
Read the drift code ↗expect_columns_exist · expect_no_nulls · expect_value_range · expect_unique fail fast with a clear ExpectationError instead of training on bad data.
Read the checks ↗skyulf-core runs end to end on house prices, disaster tweets, mall customers, forest cover, Santander, credit-card fraud, Spaceship Titanic and online retail, plus a quickstart and the leakage walkthrough.
Browse the notebooks ↗Tabular Classification, Tabular Regression, Text Classification, Customer Segmentation and Ensemble Classification open as ready pipelines you can run and then change.
Try them in the demo ↗Ready configs for guided classification, tuning, serverless and time-based setups, plus three example projects: NYC Taxi, a real air-quality dataset and a Lakeflow pipeline.
See the examples ↗The step-order check, run records, comparison, serving and drift reports you would otherwise write by hand.
Nothing is uploaded and nothing is billed per prediction; a trained model exports as a standalone project.
Every pipeline exports to a runnable notebook and runs from the Apache-2.0 library with no UI.
Kayra is two things that share one engine: skyulf-core, a Python library that gives you a single pipeline API over scikit-learn, and a self-hosted workspace where you build that same pipeline on a canvas. It covers the parts a notebook leaves to you: ordering steps so the test set stays untouched, versioning every run, comparing experiments, serving a model and watching it drift.
Sky is the open space above Earth, where the sun, moon, stars, and clouds live. Ulf means "wolf", with Nordic roots, and the wolf is also a strong symbol in Turkic tradition. Together it fits the project: independent and community-driven.
You can try the hosted demo first, with nothing to install. For real work you run it yourself with docker compose up, which takes a few minutes and needs no account, no credit card and no per-prediction bill. Because it runs on your machine or your server, your data never has to leave it, which is what makes it usable in hospitals, banks and anywhere else the data legally cannot go to a third party.
Cloud platforms require uploading your data to third-party servers and charge based on usage. Kayra runs on your own hardware or inside your private cloud. No data leaves your network, no usage-based pricing, and no vendor dependencies.
Yes. skyulf-core, the Python library, is Apache 2.0, so you can use it in anything, including closed-source commercial products. The platform (backend and canvas) is AGPLv3, so improvements to the application itself are shared back.
Yes. In the Model Registry, Export project downloads a ZIP with the fitted model and its preprocessing, a FastAPI service and a batch command for CSV or Parquet files. It installs from its own pinned requirements and needs no Kayra server or database. Pipelines that depend on other rows, such as lag or rolling-window features, are exported as a notebook instead. See the project export quickstart.
It is perfect for internal tools, research, and experimentation. We are working towards a stable v1.0 for critical production workloads.
Contributions are welcome. Start at GitHub. Whether it's code, documentation, bug reports, or feature ideas, every contribution helps.
Building on skyulf-core (Apache 2.0) is free for any use, commercial included. The platform is AGPLv3: running it internally, unmodified, needs nothing from you, but offering a modified version as a public network service means publishing your source, or asking for a commercial exception.