Skip to main content

ML Classical

Curated gradient-boosting, tree-ensemble and linear models for tabular classification and regression — CPU-first, with GPU-accelerated variants where they help.

Curated base + import anything

These are ColabHive's curated, trainable tabular models. On top of them you can import any model from Hugging Face (POST /api/builder/v1/models/hf/register) for inference, or register your own trained model as an endpoint. See Model Catalog & Hugging Face.

The models​

Every model below is a trainable template: upload a tabular dataset, call client.training.create(model="<model-id>", …), then register the result for inference. All are lifecycle=ready and active in the live catalog. GPU column is derived from each model's real vram_required_mb (CPU = no VRAM reserved).

Regression​

Model ID (model=)FrameworkHardwareNotes
xgboost-regressionxgboostCPUGradient-boosted trees, multi-output.
xgboost-regression-gpuxgboostGPUSame as above, GPU histogram training.
lightgbm-regression-gpulightgbmGPULeaf-wise boosting for large/wide data.
catboost-regressioncatboostCPUNative categorical handling.
random-forest-regressionscikit-learnCPUBagged tree ensemble, multi-output.
linear-regressionscikit-learnCPUFast, interpretable baseline.
svr-regressionscikit-learnCPUSupport-vector regression (kernel).
ngboost-regressionngboostCPUDistributional regression (mean + std, optional conformal intervals).

Classification​

Model ID (model=)FrameworkHardwareNotes
xgboost-classificationxgboostCPUGradient-boosted trees for classification.
lightgbm-classificationlightgbmCPULeaf-wise boosting for classification.
catboost-classificationcatboostCPUNative categorical handling.
random-forest-classificationscikit-learnCPUBagged tree ensemble.
logistic-regressionscikit-learnCPULinear classifier (name is historical — it is a classifier).
svm-classificationscikit-learnCPUSupport-vector classification (kernel).

The always-current list (with status and requirements) comes from the live catalog: GET /api/builder/v1/inference/models?category=ml_classical. Use the exact model_name from that list as the model= argument — there are no hidden -gpu variants beyond the two shown above.

When to use which​

  • XGBoost / LightGBM / CatBoost — strongest general-purpose tabular learners. Start here for most structured-data problems. LightGBM leans faster on very wide/large datasets; CatBoost shines with many categorical columns.
  • Random Forest — robust, low-tuning baseline; good when you want stability over peak accuracy.
  • Linear / Logistic regression — fast, interpretable baselines; good sanity checks and for genuinely linear relationships.
  • SVR / SVM — kernel methods for smaller datasets with non-linear boundaries.
  • NGBoost — when you need calibrated uncertainty (a predictive distribution, not just a point). See NGBoost Regression.

GPU vs CPU: these algorithms are CPU-first. The xgboost-regression-gpu and lightgbm-regression-gpu variants exist for large datasets where GPU histogram training pays off; pick the plain (CPU) IDs otherwise.

Quick start​

from colabhive import ColabHive

client = ColabHive(api_key="your_api_key", account_id="your_account_id")

dataset = client.datasets.upload(name="my_dataset", file="./data.csv")

job = client.training.create(
    model="xgboost-classification",          # any Model ID from the tables above
    dataset_id=dataset.id,
    hyperparameters={"target_column": "label"},
)
job.wait()
print(job.get_metrics())

# Register the trained model as a private inference endpoint
endpoint = client.training.register_for_inference(
    run_id=job.id,
    name="my-classifier",
    description="XGBoost classifier",
    visibility="account",
)

Dataset requirements​

Tabular data in CSV, JSONL, or Parquet (the canonical dataset formats are jsonl, parquet, hf_dataset, csv):

feature1,feature2,category,target
1.2,3.4,A,10.5
2.3,4.5,B,15.2
  • Feature columns: numeric or categorical.
  • Target: one column (target_column) or several (target_columns, for multi-output regressors).
  • Minimum samples: works from ~50 rows; a few hundred or more is recommended for stable metrics.

Per-model pages​

The remaining IDs (CatBoost, linear/logistic, SVM/SVR, and the -classification variants) share the same tabular pipeline shown above — swap the model= argument.