Read the public CSV and drop the ID column, which tells a model nothing about churn.
\nimport pandas as pd\nfrom welt import Client\n\nurl = "https://raw.githubusercontent.com/IBM/telco-customer-churn-on-icp4d/master/data/Telco-Customer-Churn.csv"\ncustomers = pd.read_csv(url).drop(columns="customerID")\ncustomers["TotalCharges"] = pd.to_numeric(customers["TotalCharges"], errors="coerce")\nprint(customers.shape, customers["Churn"].value_counts().to_dict())Set aside 20 customers to score at the end, and keep the rest for the models to learn from.
\nnew_rows = customers.sample(20, random_state=1)\ntable = customers.drop(new_rows.index)TabICLv2 and Kumo Tabular Medium compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each customer's chance of leaving next to what they did.
\nwith Client() as client:\n evaluation = client.evaluate(table, "Churn", task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns="Churn")\nprint(pd.DataFrame({"actual": new_rows["Churn"].values,\n "chance of leaving": model.predict_proba(features)[:, 1]}))A year of daily sales for three stores, busier at weekends.
\nimport numpy as np\nimport pandas as pd\n\nrng = np.random.default_rng(0)\ndays = pd.date_range("2025-01-01", periods=365, freq="D")\nhistory = pd.concat([pd.DataFrame({\n "date": days, "store": store,\n "sales": level * (1 + 0.3 * (days.dayofweek >= 5)) + rng.normal(0, 5, len(days)),\n}) for store, level in {"north": 120, "south": 90, "east": 60}.items()], ignore_index=True)Chronos-2 reads all three series in one request.
\nfrom welt import Forecast\n\nmodel = Forecast(model="chronos-2").fit(history, time="date", id="store", target=["sales"])\nresult = model.forecast(14, quantile_levels=[0.1, 0.5, 0.9])The median is the plan. The 10% and 90% columns show a low and a high day to plan stock around.
\nplan = result.to_frame()\nprint(plan[["id", "timestamp", "median", "q_0.1", "q_0.9"]].head(14))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="sales dataset machine weather holiday", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="wholesale customers annual spending", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="1000 cameras", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="automobile specifications prices", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="credit score classification", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="multiclass classification corporate credit ratings", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="SBA small business loan California", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="HMEQ loan default", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="credit risk dataset", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="credit risk China", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Polish companies bankruptcy three-year", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="audit data fraudulent firm", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client, Forecast\n\nwith Client() as client:\n item = client.research_datasets(q="top 100 cryptocurrency 2020", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Keep the time column and the target, for the series you want.
\ntime, series = "date", "name"\nhistory = data[data[series].isin(["Bitcoin", "Ethereum", "Litecoin"])][[series, time, target]].dropna()\nhistory[time] = pd.to_datetime(history[time])Ask for the next 14 steps, one per day. The median is the forecast, and the 10% and 90% columns give a low and a high case.
\nmodel = Forecast(model="chronos-2").fit(history, time=time, id=series, target=[target])\nresult = model.forecast(14, quantile_levels=[0.1, 0.5, 0.9])\nprint(result.to_frame()[["id", "timestamp", "median", "q_0.1", "q_0.9"]].head(14))Read FRED's CSV straight into pandas.
\nimport pandas as pd\n\nurl = "https://fred.stlouisfed.org/graph/fredgraph.csv?id=UNRATE"\nrate = pd.read_csv(url, parse_dates=["observation_date"])Ask Chronos-2 for several quantiles, so you can see the whole spread of outcomes.
\nfrom welt import Forecast\n\nlevels = [0.05, 0.1, 0.5, 0.9, 0.95]\nmodel = Forecast(model="chronos-2").fit(\n rate, time="observation_date", target=["UNRATE"], frequency="MS")\nmonth3 = model.forecast(3, quantile_levels=levels).to_frame().iloc[-1]Find where today's rate falls inside the forecast's spread. The share of outcomes above it is the probability of \"higher\".
\nimport numpy as np\n\ntoday = rate["UNRATE"].iloc[-1]\nvalues = [month3[f"q_{q}"] for q in levels]\np_higher = 1 - np.interp(today, values, levels)\nprint(f"Chance unemployment is higher in three months: {p_higher:.0%}")Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="bengaluru real estate prices", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Munich rent index", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="houses California median value", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="US property tax rates 2026 by city", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Riga real estate listings", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Dubai apartment properties", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="real estate valuation Sindian", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Read the UCI file, name the columns, and turn the outcome into yes or no.
\nimport pandas as pd\nfrom welt import Client\n\nurl = "https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/processed.cleveland.data"\ncols = ["age", "sex", "cp", "trestbps", "chol", "fbs", "restecg",\n "thalach", "exang", "oldpeak", "slope", "ca", "thal", "disease"]\npatients = pd.read_csv(url, names=cols, na_values="?")\npatients["disease"] = (patients["disease"] > 0).map({True: "yes", False: "no"})\nprint(patients.shape, patients["disease"].value_counts().to_dict())Set aside 20 patients to score at the end, and keep the rest for the models to learn from.
\nnew_rows = patients.sample(20, random_state=1)\ntable = patients.drop(new_rows.index)On a table this small, every prediction model in the collection can take part, and the baseline line shows what a guess would score. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each patient's risk next to their diagnosis.
\nwith Client() as client:\n evaluation = client.evaluate(table, "disease", task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns="disease")\nprint(pd.DataFrame({"actual": new_rows["disease"].values,\n "risk": model.predict_proba(features)[:, 1]}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="french dental lifestyle periodontal", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="diabetic retinopathy Debrecen", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="hypothyroid", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="cardiotocography fetal health", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="breast cancer Wisconsin original", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="mammographic mass", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Medicare inpatient hospitals provider service 2019", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="AIP cumulative type 2 diabetes CKD", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client, Forecast\n\nwith Client() as client:\n item = client.research_datasets(q="Data on COVID-19 country statistics", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Keep the time column and the target, for the series you want.
\ntime, series = "date", "location"\nhistory = data[data[series].isin(["France", "Germany", "Italy"])][[series, time, target]].dropna()\nhistory[time] = pd.to_datetime(history[time])Ask for the next 28 steps, one per day. The median is the forecast, and the 10% and 90% columns give a low and a high case.
\nmodel = Forecast(model="chronos-2").fit(history, time=time, id=series, target=[target])\nresult = model.forecast(28, quantile_levels=[0.1, 0.5, 0.9])\nprint(result.to_frame()[["id", "timestamp", "median", "q_0.1", "q_0.9"]].head(28))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="EEG eye state", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="populist party support medical trust COVID-19 vaccine Japan", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="zoo animal", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="yeast protein localization", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="assortative mating Littoraria", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="whooping crane stopover", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="red squirrel acceleration", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="tree performance climate suitability", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="forest cover type covertype", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="dry bean", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="rice Cammeo Osmancik", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="raisin grain", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="wheat water stress texture", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="white wine quality", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="contaminant detection cocoa hazelnut", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Tamil Nadu crop production", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client, Forecast\n\nwith Client() as client:\n item = client.research_datasets(q="Mauna Loa weekly CO2", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Keep the time column and the target.
\ntime = "date"\nhistory = data[[time, target]].dropna()\nhistory[time] = pd.to_datetime(history[time])\nhistory = history.sort_values(time)Ask for the next 52 steps, one per week. The median is the forecast, and the 10% and 90% columns give a low and a high case.
\nmodel = Forecast(model="chronos-2").fit(history, time=time, target=[target])\nresult = model.forecast(52, quantile_levels=[0.1, 0.5, 0.9])\nprint(result.to_frame()[["timestamp", "median", "q_0.1", "q_0.9"]].head(52))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="El Nino buoy", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="SoilHydroDB", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="DMI Aarhus weather", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="wind 503", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Barkley Canyon biopump", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Beijing PM2.5", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Los Angeles ozone 1976", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="urban land-cover Ouagadougou", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="satellite image attributes", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="steel industry energy consumption", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="power consumption Tetouan", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="solar radiation prediction", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="electrical grid stability", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="daily electric energy Spain", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client, Forecast\n\nwith Client() as client:\n item = client.research_datasets(q="electricity prices ICON 2014", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Keep the time column and the target.
\ntime = "datetime"\nhistory = data[[time, target]].dropna()\nhistory[time] = pd.to_datetime(history[time])\nhistory = history.sort_values(time).tail(8000)Ask for the next 48 steps, one per half-hour. The median is the forecast, and the 10% and 90% columns give a low and a high case.
\nmodel = Forecast(model="chronos-2").fit(history, time=time, target=[target])\nresult = model.forecast(48, quantile_levels=[0.1, 0.5, 0.9])\nprint(result.to_frame()[["timestamp", "median", "q_0.1", "q_0.9"]].head(48))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="gas turbine CO NOx emissions", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="TUPRAS boiler", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="appliances energy prediction", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Search the research catalogue and load the table into a DataFrame.
\nfrom welt import Client\n\nwith Client() as client:\n page = client.research_datasets(q="yacht", availability="available", limit=5)\n yachts = client.load_research_dataset(page["items"][0]["id"])Keep 30% of the tests aside, so you can check the predictions against real measurements.
\nfrom sklearn.model_selection import train_test_split\n\ntarget = "Residuary.resistance"\ntrain, test = train_test_split(yachts, test_size=0.3, random_state=9)Fit on the training rows and predict the held-back ones. There's nothing to tune.
\nfrom welt import Regressor\nfrom sklearn.metrics import mean_absolute_error\n\nmodel = Regressor(model="tabicl-v2", random_state=9)\nmodel.fit(train, target=target)\npredictions = model.predict(test.drop(columns=target))\nprint("Average error:", mean_absolute_error(test[target], predictions))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="statlog shuttle", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="AI4I 2020 predictive maintenance", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="NASA PHM2008", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="BMC building characteristics", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="ailerons", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="bus breakdown delays NYC", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="FARS motor vehicle crash person", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="sonar mines rocks", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="vehicle shape features", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="gesture phase segmentation", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="waveform 21", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="LED display digits", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="MAGIC gamma telescope", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Higgs boson detection", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="MiniBooNE particle", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="AqSolDB aqueous solubility", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="glass binarized", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="balance scale", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="student performance analysis", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="human memory cognition storytelling", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="eye movements relevance", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="first-order theorem proving", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="MA-BBOB DiagonalCMA", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="container pre-marshalling", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="phishing websites", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 4,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(4000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="spambase", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="code smells data class", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="hottest Kaggle datasets", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="page blocks", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="connect-4", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="League of Legends diamond matches 15 minutes", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 8,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(8000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Overwatch competitive matches", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end. The models learn from a seeded sample of 2,000 of the rest, the most this table's width allows.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index).sample(2000, random_state=7)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="SkillCraft1 StarCraft 2", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Pokemon 2020", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="Nintendo 3DS games", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2", "tabdpt-1.3"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="football player position", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. ROC AUC runs from 0.5, a coin toss, to 1, a perfect ranking, and a lower Brier score means the probabilities can be trusted more. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="classification", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "roc_auc_mean", "brier_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features),\n "probability": model.predict_proba(features).max(axis=1)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="IMDB movies 1972-2019", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))Find the table, read its recorded target and print the column names.
\nimport pandas as pd\nfrom welt import Client\n\nwith Client() as client:\n item = client.research_datasets(q="anime-planet", limit=1)["items"][0]\n info = client.research_dataset(item["id"])\n data = client.load_research_dataset(item["id"])\n\ntarget = info["targets"][0]\ntarget = target["name"] if isinstance(target, dict) else target\nprint([column["name"] for column in info["schema"]], target)Set aside 20 rows to predict at the end, and keep the rest for the models to learn from.
\nknown = data.dropna(subset=[target])\nnew_rows = known.sample(20, random_state=1)\ntable = known.drop(new_rows.index)The models compete on the same folds against a simple guess, then the top-ranked one is fitted on the whole table. RMSE and MAE are average errors in the target's own units, so lower is better. The last table puts each prediction next to the real answer.
\nwith Client() as client:\n evaluation = client.evaluate(table, target, task="regression", seed=7,\n models=["tabicl-v2", "kumo-medium", "mitra-v2"])\n model = evaluation.fit()\n\nprint(evaluation.summary()[["name", "rank", "rmse_mean", "mae_mean"]])\nfeatures = new_rows.drop(columns=target)\nprint(pd.DataFrame({"actual": new_rows[target].values, "predicted": model.predict(features)}))