MLAgentBench protocol setup (improve a provided train.py); retire from-scratch tree

.gitattributes

@@ -62,3 +62,6 @@ datasets/mlab-real/imdb/environment/data/train.csv filter=lfs diff=lfs merge=lfs
 datasets/mlab-real/imdb-base/environment/data/train.csv filter=lfs diff=lfs merge=lfs -text
 datasets/mlab-real/amp-parkinsons/environment/data/train_peptides.csv filter=lfs diff=lfs merge=lfs -text
 datasets/mlab-real/imdb/environment/data/test.csv filter=lfs diff=lfs merge=lfs -text
+datasets/mlab-protocol/amp-parkinsons/environment/data/train_peptides.csv filter=lfs diff=lfs merge=lfs -text
+datasets/mlab-protocol/imdb/environment/data/test.csv filter=lfs diff=lfs merge=lfs -text
+datasets/mlab-protocol/imdb/environment/data/train.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,33 +1,41 @@
 # harbor-datasets-mlab
 
-Harbor-format **MLAB** benchmark (MLAgentBench, arXiv:2310.03302): 9 real ML tasks across tabular / text / vision / graph / segmentation (fathomnet + identify-contrails are ≤5 GB competition subsets, the rest full). A general benchmark for
-**any Harbor agent** — tasks are agent-neutral and **self-contained**.
-`registry.json` at the root, **one folder per task**.
+Harbor-format **MLAgentBench** (arXiv:2310.03302), posed under the benchmark's own
+protocol: every workspace already contains a `train.py` that runs end to end but
+scores poorly, and the task is to **improve it** — not to solve the problem from an
+empty directory. Task descriptions are MLAgentBench's `research_problem.txt` verbatim.
+
+10 tasks across tabular / text / vision / graph / segmentation / algorithmic. Agent-neutral
+and self-contained: `registry.json` at the root, one folder per task.
 
 ## What each task contains
 ```
-datasets/mlab-real/<task>/
+datasets/mlab-protocol/<task>/
   environment/Dockerfile      # builds FROM python:3.12-slim — no external base image
   environment/requirements.txt
-  environment/prepare.py      # stages the data into /workspace at build time
-  environment/data/           # the real data
-  instruction.md              # task description + submission format (agent-neutral)
+  environment/prepare.py      # stages the data AND train.py into /workspace at build time
+  environment/data/           # the real data + the starter train.py
+  instruction.md              # research_problem.txt + submission format (agent-neutral)
   tests/                      # scorer + verifier
   task.toml                   # Harbor task config
 ```
-Nothing outside this repository is required: no private images, no extra repos,
-no tokens. `docker build` pulls only `python:3.12-slim` and public PyPI/apt
-packages. The agent is installed by Harbor itself, so any agent works.
+The answer key never reaches the workspace — `prepare.py` puts it aside in `/opt/mlab`,
+where the scorer reads it.
+
+Tasks: spaceship-titanic, house-price, amp-parkinsons, imdb, feedback, cifar10,
+ogbn-arxiv, fathomnet, identify-contrails, clrs.
 
-Tasks (`-i`): spaceship-titanic, house-price, amp-parkinsons, imdb, feedback, cifar10, ogbn-arxiv, fathomnet, identify-contrails.
+Data: 8 tasks full; fathomnet and identify-contrails are subsets sized to fit the
+repository (identify-contrails is 155 records × 3 of 8 frames in float16, so its absolute
+Dice is not comparable to the competition leaderboard); clrs is synthetic by construction,
+from the official `dm-clrs` sampler.
+
+## Metrics
+Each task is scored by the metric MLAgentBench's own `eval.py` uses: accuracy
+(spaceship-titanic, imdb, cifar10, ogbn-arxiv), MAE (house-price), SMAPE (amp-parkinsons),
+MCRMSE (feedback), MAP@20 (fathomnet), Dice (identify-contrails), pointer accuracy (clrs).
 
 ## Run
 ```bash
-REPO=https://huggingface.co/datasets/danil-e/harbor-datasets-mlab
-harbor run --repo $REPO -d mlab-real -i feedback -a <agent> -m <model>
+harbor run --local . mlab/house-price
 ```
-The task image is built on first run (installs the task's Python stack, so the
-first build takes a few minutes; later runs reuse the cached image).
-
-Harbor's other environment backends (`-e ...`, e.g. for hosts without a Docker
-daemon) work the same way — see the Harbor documentation for their requirements.

datasets/mlab-protocol/README.md

@@ -0,0 +1,9 @@
+# mlab-protocol
+
+One folder per task, posed the way MLAgentBench poses it: the workspace already
+contains a `train.py` that runs end to end but scores poorly, and the task is to
+improve it. The task description is MLAgentBench's own `research_problem.txt`.
+
+Each task is self-contained — real data (`<task>/environment/data/`), a Dockerfile
+building from `python:3.12-slim`, `instruction.md`, and a scorer in `tests/`.
+The answer key never enters the workspace; `prepare.py` puts it aside in `/opt/mlab`.

datasets/mlab-protocol/amp-parkinsons/environment/data/train.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import RandomForestRegressor
+
+TARGETS = ['updrs_1', 'updrs_2', 'updrs_3', 'updrs_4']
+
+
+def smapep1(y_true, y_pred):
+    """SMAPE with +1 offset, as used by the competition (lower is better)."""
+    y_true = np.asarray(y_true, dtype=float) + 1
+    y_pred = np.clip(np.asarray(y_pred, dtype=float), 0, None) + 1
+    denom = (np.abs(y_true) + np.abs(y_pred)) / 2
+    return 100 * np.mean(np.abs(y_true - y_pred) / denom)
+
+
+clinical = pd.read_csv('train_clinical_data.csv')
+test = pd.read_csv('test.csv')
+
+## TODO: data cleaning and feature engineering
+## right now only visit_month is used as a feature
+
+model = {}
+for u in TARGETS:
+    df = clinical[['visit_month', u]].dropna()
+    X = df['visit_month'].values.reshape(-1, 1)
+    y = df[u].values
+    trained = RandomForestRegressor().fit(X, y)
+    model[u] = trained
+    print(f'{u}: train SMAPE = {smapep1(y, trained.predict(X)):.2f}')
+
+months = test['visit_month'].values.reshape(-1, 1)
+out = {'visit_id': test['visit_id'].values}
+for u in TARGETS:
+    out[u] = model[u].predict(months)
+pd.DataFrame(out).to_csv('submission.csv', index=False)
+print('wrote submission.csv')

datasets/{mlab-real → mlab-protocol}/amp-parkinsons/environment/prepare.py

@@ -7,5 +7,8 @@ for f in ['train_clinical_data.csv', 'train_proteins.csv', 'train_peptides.csv',
     if (SRC/f).exists(): shutil.copy(SRC/f, WS/f)
 for d in []:
     if (SRC/d).exists(): shutil.copytree(SRC/d, WS/d, dirs_exist_ok=True)
+for f in ("train.py",):
+    if (SRC/f).exists(): shutil.copy(SRC/f, WS/f)
+
 shutil.copy(SRC/"answer.csv", ANS/"answer.csv")
 print("[prepare] staged", os.listdir(WS))

datasets/mlab-protocol/amp-parkinsons/instruction.md

@@ -0,0 +1,32 @@
+# amp-parkinsons — improve the provided training script
+
+Go through the data_description.txt file to understand the data and the machine learning task. You can summarize it in your research logs to keep track of what all you have to do. Then fill in the provided train.py script to train a model and iterate over different models or feature selections to get a better performance (for SMAPE score the lower is better). Finally, you should submit the predictions of your best model for the test set as a submission.csv as described in the evaluation_details.txt file.
+
+## Data (already staged in `/workspace`)
+The files referenced by `train.py` are in the working directory. `train.py` runs as
+provided.
+
+## Submission — REQUIRED
+Write `submission.csv` with columns `visit_id,updrs_1,updrs_2,updrs_3,updrs_4`.
+
+Scoring: **SMAPE** (LOWER is better) on a held-out split.
+
+## Valid submission — REQUIRED
+Your predictions MUST come from a model fitted on the features. A constant submission
+is not an answer, even if the metric happens to reward it: predictions have to vary
+across rows, and for a multi-target problem across every target. Before writing the
+file, print the number of distinct predicted values per column; if any column has
+fewer than 10 distinct values, the model has collapsed — fix it rather than submit it.
+
+## Hardware — REQUIRED
+Resolve the compute device with EXACTLY this snippet before training, and use it
+for the model and for every batch:
+```python
+import torch
+DEVICE = ('cuda' if torch.cuda.is_available()
+          else 'mps' if torch.backends.mps.is_available() else 'cpu')
+print('DEVICE=', DEVICE)
+```
+Do **not** hardcode `'cuda'` and do **not** write a CUDA-only check like
+`'cuda' if torch.cuda.is_available() else 'cpu'`: on a machine whose accelerator is
+Apple MPS that silently falls back to CPU and training becomes far slower.

datasets/{mlab-real → mlab-protocol}/amp-parkinsons/task.toml

@@ -3,14 +3,14 @@ artifacts = ["/workspace/submission.csv"]
 
 [task]
 name = "mlab/amp-parkinsons"
-description = "MLAgentBench amp-parkinsons — full competition data (SMAPE)"
-keywords = ["mlab", "mlagentbench", "tabular", "full-data"]
+description = "MLAgentBench amp-parkinsons — MLAgentBench protocol: improve the provided train.py"
+keywords = ["mlab", "mlagentbench", "tabular", "full-data", "protocol"]
 [[task.authors]]
 name = "mlab"
 
 [metadata]
 family = "tabular"
-metric = "SMAPE"
+metric = "smape"
 
 [verifier]
 timeout_sec = 1800.0

datasets/mlab-protocol/cifar10/environment/data/train.py

@@ -0,0 +1,64 @@
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import TensorDataset, DataLoader
+
+device = ('cuda' if torch.cuda.is_available()
+          else 'mps' if torch.backends.mps.is_available() else 'cpu')
+print('DEVICE=', device)
+
+X = np.load('train_images.npy').astype(np.float32) / 255.0
+y = pd.read_csv('train.csv')['label'].values
+Xte = np.load('test_images.npy').astype(np.float32) / 255.0
+te_ids = pd.read_csv('test.csv')['id'].values
+
+X = torch.tensor(X).permute(0, 3, 1, 2)
+Xte = torch.tensor(Xte).permute(0, 3, 1, 2)
+y = torch.tensor(y, dtype=torch.long)
+
+
+class Net(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1 = nn.Conv2d(3, 6, 5)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = torch.flatten(x, 1)
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        return self.fc3(x)
+
+
+model = Net().to(device)
+optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
+criterion = nn.CrossEntropyLoss()
+loader = DataLoader(TensorDataset(X, y), batch_size=128, shuffle=True)
+
+epochs = 5
+for epoch in range(epochs):
+    running = 0.0
+    for xb, yb in loader:
+        xb, yb = xb.to(device), yb.to(device)
+        optimizer.zero_grad()
+        loss = criterion(model(xb), yb)
+        loss.backward()
+        optimizer.step()
+        running += loss.item()
+    print(f'epoch {epoch} loss {running / len(loader):.4f}')
+
+model.eval()
+preds = []
+with torch.no_grad():
+    for i in range(0, len(Xte), 512):
+        preds.append(model(Xte[i:i + 512].to(device)).argmax(1).cpu().numpy())
+pd.DataFrame({'id': te_ids, 'label': np.concatenate(preds)}).to_csv('submission.csv', index=False)
+print('wrote submission.csv')

datasets/{mlab-real → mlab-protocol}/cifar10/environment/prepare.py

@@ -7,5 +7,8 @@ for f in ("train.csv","test.csv"):
     shutil.copy(SRC/f, WS/f)
 for f in ("train_images.npy","test_images.npy","node_features.npy","edges.npy"):
     if (SRC/f).exists(): shutil.copy(SRC/f, WS/f)
+for f in ("train.py",):
+    if (SRC/f).exists(): shutil.copy(SRC/f, WS/f)
+
 shutil.copy(SRC/"answer.csv", ANS/"answer.csv")
 print("[prepare] REAL mlab cifar10 (image 10-class, real split): staged", os.listdir(WS))

datasets/mlab-protocol/cifar10/instruction.md

@@ -0,0 +1,25 @@
+# cifar10 — improve the provided training script
+
+Given a training script on a dataset train.py, improve upon the current model performance (trained with current hyperparmeters in train.py). The training epochs should be within 10 to save time. Save per class probabilities for test set examples to submission.csv as shown in train.py.
+
+## Data (already staged in `/workspace`)
+The files referenced by `train.py` are in the working directory. `train.py` runs as
+provided.
+
+## Submission — REQUIRED
+Write `submission.csv` with columns `id,label` — one predicted class index (0-9) per test image.
+
+Scoring: **accuracy** (higher is better) on a held-out split.
+
+## Hardware — REQUIRED
+Resolve the compute device with EXACTLY this snippet before training, and use it
+for the model and for every batch:
+```python
+import torch
+DEVICE = ('cuda' if torch.cuda.is_available()
+          else 'mps' if torch.backends.mps.is_available() else 'cpu')
+print('DEVICE=', DEVICE)
+```
+Do **not** hardcode `'cuda'` and do **not** write a CUDA-only check like
+`'cuda' if torch.cuda.is_available() else 'cpu'`: on a machine whose accelerator is
+Apple MPS that silently falls back to CPU and training becomes far slower.

datasets/{mlab-real → mlab-protocol}/cifar10/task.toml

@@ -2,8 +2,8 @@ schema_version = "1.3"
 artifacts = ["/workspace/submission.csv"]
 [task]
 name = "mlab/cifar10"
-description = "MLAgentBench CIFAR-10 (small) — image classification (timm / torchvision)"
-keywords = ["mlab", "mlagentbench", "image", "vision", "torchvision"]
+description = "MLAgentBench CIFAR-10 (small) — MLAgentBench protocol: improve the provided train.py"
+keywords = ["mlab", "mlagentbench", "image", "vision", "torchvision", "protocol"]
 [[task.authors]]
 name = "mlab"
 [metadata]

datasets/{mlab-real/identify-contrails/environment/data/test/1002860788164505892/band_11.npy → mlab-protocol/clrs/environment/data/answer.npz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:21e2a1291fb41bd08fe9463635f51fbe7521342fc7575b3bc90343affc390cb0
-size 2097280
+oid sha256:ba0da261661fe4309243f42d578d7038b438c7daee17ce292af390b2d28c1495
+size 2763560

datasets/{mlab-real/identify-contrails/environment/data/test/1002860788164505892/band_14.npy → mlab-protocol/clrs/environment/data/test.npz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1452e19cdff9c724c87b0e0f3f726cc2cab9057f1e7dc1937edfd4fb8cffe2ea
-size 2097280
+oid sha256:fa3d4880575957485b768f6ed3e502dbc0d3fc9d9a6723fe0398582cf0ea4dd1
+size 4732006

datasets/{mlab-real/identify-contrails/environment/data/test/1002860788164505892/band_15.npy → mlab-protocol/clrs/environment/data/train.npz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:df4b1ae667d8df133cf273193e5070d21c877d6b9c5856e9e27fcafc90059952
-size 2097280
+oid sha256:92e8e16be35b3eddd0d1e707b5ba315ac5089d92afacf34be476b7ee789c8ba7
+size 4295351

datasets/mlab-protocol/clrs/environment/data/train.py

@@ -0,0 +1,63 @@
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+
+device = ('cuda' if torch.cuda.is_available()
+          else 'mps' if torch.backends.mps.is_available() else 'cpu')
+print('DEVICE=', device)
+
+tr = np.load('train.npz')
+te = np.load('test.npz')
+A_tr, Pi_tr = tr['A'].astype(np.float32), tr['Pi'].astype(np.int64)
+A_te = te['A'].astype(np.float32)
+N_tr, N_te = A_tr.shape[1], A_te.shape[1]
+
+epochs = 5      # weak baseline: scores each candidate from two edge weights only
+
+
+class Baseline(nn.Module):
+    """For pair (i, j) and candidate k, score it from A[i, k] and A[k, j] alone."""
+
+    def __init__(self, hidden=32):
+        super().__init__()
+        self.net = nn.Sequential(nn.Linear(2, hidden), nn.ReLU(), nn.Linear(hidden, 1))
+
+    def forward(self, A):                            # A: (B, N, N)
+        B, N, _ = A.shape
+        ik = A.unsqueeze(2).expand(B, N, N, N)       # A[b, i, k] over (i, j, k)
+        kj = A.unsqueeze(1).transpose(2, 3).expand(B, N, N, N)   # A[b, k, j]
+        feat = torch.stack([ik, kj], dim=-1)         # (B, N, N, N, 2)
+        return self.net(feat).squeeze(-1)            # (B, N, N, N) logits over k
+
+
+model = Baseline().to(device)
+opt = torch.optim.Adam(model.parameters(), lr=1e-3)
+lossf = nn.CrossEntropyLoss()
+
+X, Y = torch.tensor(A_tr), torch.tensor(Pi_tr)
+for epoch in range(epochs):
+    model.train()
+    perm = torch.randperm(len(X))
+    total, nb = 0.0, 0
+    for i in range(0, len(X), 32):
+        idx = perm[i:i + 32]
+        xb, yb = X[idx].to(device), Y[idx].to(device)
+        opt.zero_grad()
+        logits = model(xb)                            # (B, N, N, N)
+        loss = lossf(logits.reshape(-1, N_tr), yb.reshape(-1))
+        loss.backward()
+        opt.step()
+        total += loss.item(); nb += 1
+    print(f'epoch {epoch} loss {total / max(nb, 1):.4f}')
+
+model.eval()
+rows = []
+with torch.no_grad():
+    for g in range(len(A_te)):
+        pred = model(torch.tensor(A_te[g:g + 1]).to(device)).argmax(-1)[0].cpu().numpy()
+        for r in range(N_te):
+            rows.append({'graph_id': g, 'row': r,
+                         'pointers': ' '.join(str(int(v)) for v in pred[r])})
+pd.DataFrame(rows).to_csv('submission.csv', index=False)
+print('wrote submission.csv')

datasets/mlab-protocol/clrs/environment/prepare.py

@@ -0,0 +1,12 @@
+"""Stage the CLRS task data into the workspace at build time."""
+import os, shutil
+from pathlib import Path
+WS=Path(os.environ.get("MLAB_WORKSPACE","/workspace")); ANS=Path(os.environ.get("MLAB_ANSWER_DIR","/opt/mlab"))
+SRC=Path("/opt/mlab/data"); WS.mkdir(parents=True,exist_ok=True); ANS.mkdir(parents=True,exist_ok=True)
+for f in ("train.npz","test.npz"):
+    shutil.copy(SRC/f, WS/f)
+for f in ("train.py",):
+    if (SRC/f).exists(): shutil.copy(SRC/f, WS/f)
+
+shutil.copy(SRC/"answer.npz", ANS/"answer.npz")
+print("[prepare] staged", os.listdir(WS))

datasets/mlab-protocol/clrs/environment/requirements.txt

@@ -0,0 +1,5 @@
+# Graph / algorithmic-reasoning stack. torch is installed separately in the Dockerfile.
+torch-geometric
+scikit-learn
+pandas
+numpy<2

datasets/mlab-protocol/clrs/instruction.md

@@ -0,0 +1,24 @@
+# clrs — improve the provided training script
+
+Improve the baseline model performance on the task floyd_warshall in The CLRS Algorithmic Reasoning Benchmark. To run the baseline model, execute train.py. You may modify the model architecture and the training loop, but keep the data loading and the submission format as provided.
+
+## Data (already staged in `/workspace`)
+The files referenced by `train.py` are in the working directory.
+
+## Submission — REQUIRED
+Write `submission.csv` with columns `graph_id,row,pointers` (64 space-separated predecessors per row).
+
+Scoring: **pointer accuracy** (higher is better) on a held-out split.
+
+## Hardware — REQUIRED
+Resolve the compute device with EXACTLY this snippet before training, and use it
+for the model and for every batch:
+```python
+import torch
+DEVICE = ('cuda' if torch.cuda.is_available()
+          else 'mps' if torch.backends.mps.is_available() else 'cpu')
+print('DEVICE=', DEVICE)
+```
+Do **not** hardcode `'cuda'` and do **not** write a CUDA-only check like
+`'cuda' if torch.cuda.is_available() else 'cpu'`: on a machine whose accelerator is
+Apple MPS that silently falls back to CPU and training becomes far slower.

datasets/mlab-protocol/clrs/task.toml

@@ -0,0 +1,30 @@
+schema_version = "1.3"
+artifacts = ["/workspace/submission.csv"]
+
+[task]
+name = "mlab/clrs"
+description = "CLRS Algorithmic Reasoning (floyd_warshall) — MLAgentBench protocol: improve the provided train.py"
+keywords = ["mlab", "clrs", "algorithmic-reasoning", "graph", "ood", "protocol"]
+[[task.authors]]
+name = "mlab"
+
+[metadata]
+family = "graph"
+metric = "pointer_accuracy"
+
+[verifier]
+timeout_sec = 1800.0
+collect = []
+[verifier.env]
+
+[agent]
+timeout_sec = 7200.0
+
+[environment]
+network_mode = "public"
+build_timeout_sec = 3600.0
+os = "linux"
+mcp_servers = []
+[environment.env]
+
+[solution.env]

datasets/mlab-protocol/clrs/tests/score.py

@@ -0,0 +1,47 @@
+"""Score a CLRS floyd_warshall submission: pointer accuracy against the reference Pi."""
+import argparse, json, os
+import numpy as np
+import pandas as pd
+
+
+def score(submission: str, answer: str):
+    Pi = np.load(answer)["Pi"]                      # (G, n, n) int
+    G, n, _ = Pi.shape
+    pred = np.full((G, n, n), -1, dtype=np.int64)
+    df = pd.read_csv(submission)
+    need = {"graph_id", "row", "pointers"}
+    if not need.issubset(df.columns):
+        raise ValueError(f"submission must have columns {sorted(need)}")
+    for gid, row, ptr in zip(df["graph_id"], df["row"], df["pointers"]):
+        g, i = int(gid), int(row)
+        if not (0 <= g < G and 0 <= i < n):
+            continue
+        vals = np.fromstring(str(ptr), sep=" ", dtype=np.int64)
+        if vals.size != n:
+            continue
+        pred[g, i] = vals
+    acc = float((pred == Pi).mean())
+    covered = float((pred >= 0).mean())
+    return acc, {"pointer_accuracy": acc, "coverage": covered, "graphs": float(G), "n": float(n)}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--submission", required=True)
+    ap.add_argument("--answer", required=True)
+    ap.add_argument("--reward-json", required=True)
+    a = ap.parse_args()
+    try:
+        reward, extra = score(a.submission, a.answer)
+    except Exception as exc:  # noqa: BLE001 - always emit a reward
+        reward, extra = 0.0, {"error": str(exc)}
+    payload = {"reward": float(reward), **extra}
+    numeric = {k: v for k, v in payload.items() if isinstance(v, (int, float))}  # Harbor: numeric only
+    os.makedirs(os.path.dirname(a.reward_json), exist_ok=True)
+    open(a.reward_json, "w").write(json.dumps(numeric))
+    print(payload)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

datasets/{mlab-real → mlab-protocol}/dataset.toml

@@ -1,8 +1,8 @@
-# Dataset manifest for mlab-real
+# Dataset manifest for mlab-protocol
 
 [dataset]
-name = "mlab-real"
-version = "2.0"
+name = "mlab-protocol"
+version = "1.0"
 
 [[tasks]]
 name = "mlab/amp-parkinsons"
@@ -12,6 +12,10 @@ path = "amp-parkinsons"
 name = "mlab/cifar10"
 path = "cifar10"
 
+[[tasks]]
+name = "mlab/clrs"
+path = "clrs"
+
 [[tasks]]
 name = "mlab/fathomnet"
 path = "fathomnet"