Prediction - Wood Wide AI Documentation

Prediction models learn to predict a target column from the remaining columns in your dataset. Wood Wide AI automatically detects whether the task is binary classification, multiclass classification, or regression based on the target column’s values.

Training

At training time, you must specify the label_column — the column to be predicted. All other columns (or those specified via input_columns) are used as input features. A portion of the training data is automatically held out for validation. After training, validation metrics are reported on this holdout set:

Task	Metric	Description
Binary / multiclass classification	`accuracy`	Fraction of correct predictions on the holdout set.
Regression	`r2`	R-squared (coefficient of determination) on the holdout set.

These metrics are available on the model object via GET /models/{model_id} in the current_metrics field, and on each model version via GET /models/{model_id}/versions.

import os, time, requests

api_key = os.getenv("WOODWIDE_API_KEY")
base_url = "https://api.woodwide.ai"
headers = {"Authorization": f"Bearer {api_key}"}

# Upload training data
with open("train.csv", "rb") as f:
    resp = requests.post(
        f"{base_url}/datasets",
        headers=headers,
        files={"file": ("train.csv", f, "text/csv")},
        data={"dataset_name": "customer_churn"},
    )
dataset_id = resp.json()["dataset"]["id"]

# Train a prediction model
resp = requests.post(
    f"{base_url}/models/train",
    headers=headers,
    json={
        "model_name": "churn_predictor",
        "model_type": "prediction",
        "dataset_id": dataset_id,
        "label_column": "churned",
    },
)
model_id = resp.json()["model"]["id"]

# Wait for training
while True:
    model = requests.get(
        f"{base_url}/models/{model_id}", headers=headers
    ).json()
    if model["status"] == "ready":
        break
    time.sleep(5)

# Check validation metrics
print(model["current_metrics"])  # e.g. {"accuracy": 0.92}

import time
from pathlib import Path
from woodwide import WoodWide

client = WoodWide()

dataset = client.datasets.create(
    file=Path("train.csv"),
    dataset_name="customer_churn",
    override=True,
)

model = client.models.train(
    model_type="prediction",
    label_column="churned",
    dataset_id=dataset.id,
)
model_id = model.id

while True:
    model = client.models.retrieve(model_id)
    if model.status in {"ready", "failed"}:
        break
    time.sleep(5)

if model.status == "failed":
    raise RuntimeError("Training failed")
# Validation metrics: GET /models/{model_id} via HTTP (current_metrics)

const fs = require("fs");
const FormData = require("form-data");

const apiKey = process.env.WOODWIDE_API_KEY;
const baseUrl = "https://api.woodwide.ai";
const headers = { Authorization: `Bearer ${apiKey}` };

// Upload training data
const uploadForm = new FormData();
uploadForm.append("file", fs.createReadStream("train.csv"), "train.csv");
uploadForm.append("dataset_name", "customer_churn");

const uploadResp = await fetch(`${baseUrl}/datasets`, {
  method: "POST",
  headers: { ...headers, ...uploadForm.getHeaders() },
  body: uploadForm,
});
const { dataset: { id: datasetId } } = await uploadResp.json();

// Train a prediction model
const trainResp = await fetch(`${baseUrl}/models/train`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    model_name: "churn_predictor",
    model_type: "prediction",
    dataset_id: datasetId,
    label_column: "churned",
  }),
});
const { model: { id: modelId } } = await trainResp.json();

// Wait for training
let model;
while (true) {
  const modelResp = await fetch(`${baseUrl}/models/${modelId}`, { headers });
  model = await modelResp.json();
  if (model.status === "ready") break;
  await new Promise((r) => setTimeout(r, 5000));
}

// Check validation metrics
console.log(model.current_metrics);  // e.g. { accuracy: 0.92 }

export WOODWIDE_API_KEY="your_api_key_here"
export BASE_URL="https://api.woodwide.ai"

# Upload training data
DATASET_ID=$(curl -s -X POST "$BASE_URL/datasets" \
  -H "Authorization: Bearer $WOODWIDE_API_KEY" \
  -F "file=@train.csv" \
  -F "dataset_name=customer_churn" | jq -r '.dataset.id')

# Train a prediction model
MODEL_ID=$(curl -s -X POST "$BASE_URL/models/train" \
  -H "Authorization: Bearer $WOODWIDE_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model_name\": \"churn_predictor\",
    \"model_type\": \"prediction\",
    \"dataset_id\": \"$DATASET_ID\",
    \"label_column\": \"churned\"
  }" | jq -r '.model.id')

# Wait for training
while true; do
  STATUS=$(curl -s "$BASE_URL/models/$MODEL_ID" \
    -H "Authorization: Bearer $WOODWIDE_API_KEY" | jq -r '.status')

  if [ "$STATUS" = "ready" ]; then break; fi
  if [ "$STATUS" = "failed" ]; then echo "Training failed."; exit 1; fi

  sleep 5
done

# Check validation metrics
curl -s "$BASE_URL/models/$MODEL_ID" \
  -H "Authorization: Bearer $WOODWIDE_API_KEY" | jq '.current_metrics'
# e.g. { "accuracy": 0.92 }

Inference

At inference time, provide a CSV with the same input columns as the training data. The target column need not be present — if it is, it will be ignored. The model predicts the target column for each row.

# Run inference on new data
with open("test.csv", "rb") as f:
    resp = requests.post(
        f"{base_url}/models/{model_id}/infer",
        headers=headers,
        files={"file": ("test.csv", f, "text/csv")},
        data={"output_type": "json"},
    )

results = resp.json()["data"]
print(results)

# Uses client and model_id from the training example above.
from pathlib import Path

result = client.models.infer(
    model_id,
    file=Path("test.csv"),
    output_type="json",
)
print(result["data"])

// Run inference on new data
const form = new FormData();
form.append("file", fs.createReadStream("test.csv"), "test.csv");
form.append("output_type", "json");

const resp = await fetch(`${baseUrl}/models/${modelId}/infer`, {
  method: "POST",
  headers: { ...headers, ...form.getHeaders() },
  body: form,
});

const { data: results } = await resp.json();
console.log(results);

curl -s -X POST "$BASE_URL/models/$MODEL_ID/infer" \
  -H "Authorization: Bearer $WOODWIDE_API_KEY" \
  -F "file=@test.csv" \
  -F "output_type=json" | jq '.data'

See Output Formats for the full output schema.

⌘I