Agent trace

/task/:
total 36
dr-xr-xr-x 1 root root 4096 Aug 29 00:50 .
drwxr-xr-x 1 root root 4096 Aug 29 00:53 ..
-r--r--r-- 1 root root    0 Aug 29 00:37 .keep
dr-xr-xr-x 1 root root 4096 Aug 29 00:37 data
-r--r--r-- 1 root root 5774 Aug 29 00:37 evaluate_public.py
-r--r--r-- 1 root root 8265 Aug 29 00:37 ranking_evaluation.py
-r--r--r-- 1 root root 1295 Aug 29 00:37 requirements.txt

/task/data/:
total 347392
dr-xr-xr-x 1 root root      4096 Aug 29 00:37 .
dr-xr-xr-x 1 root root      4096 Aug 29 00:50 ..
-r--r--r-- 1 root root    349352 Aug 29 00:37 candidate_catalog.parquet
-r--r--r-- 1 root root     84127 Aug 29 00:37 target_users.parquet
-r--r--r-- 1 root root   7736341 Aug 29 00:37 test_eligible_candidates.npz
-r--r--r-- 1 root root   1092329 Aug 29 00:37 test_preference_state.parquet
-r--r--r-- 1 root root    857213 Aug 29 00:37 train_dislikes.parquet
-r--r--r-- 1 root root   5374652 Aug 29 00:37 train_likes.parquet
-r--r--r-- 1 root root 319183255 Aug 29 00:37 train_listens.parquet
-r--r--r-- 1 root root    155988 Aug 29 00:37 train_undislikes.parquet
-r--r--r-- 1 root root   1855885 Aug 29 00:37 train_unlikes.parquet
-r--r--r-- 1 root root     36571 Aug 29 00:37 val_dislikes.parquet
-r--r--r-- 1 root root    298484 Aug 29 00:37 val_likes.parquet
-r--r--r-- 1 root root   9947609 Aug 29 00:37 val_listens.parquet
-r--r--r-- 1 root root      7845 Aug 29 00:37 val_undislikes.parquet
-r--r--r-- 1 root root     72536 Aug 29 00:37 val_unlikes.parquet
-r--r--r-- 1 root root   7573821 Aug 29 00:37 validation_eligible_candidates.npz
-r--r--r-- 1 root root   1061761 Aug 29 00:37 validation_preference_state.parquet
# Exact distribution inventory for the Yambda two-tower task family.
#
# This is an input to `uv pip sync`, not a list of minimum requirements. A
# conforming task environment contains exactly these third-party Python
# distributions and no others. Python itself is pinned by task.toml and both
# Harbor image Dockerfiles.
attrs==26.1.0
bleach==6.4.0
certifi==2026.7.22
chardet==7.6.0
charset-normalizer==3.5.1
fastjsonschema==2.22.2
filelock==3.32.3
fsspec==2026.7.0
idna==3.18
Jinja2==3.1.6
joblib==1.5.3
jsonschema==4.26.0
jsonschema-specifications==2025.9.1
jupyter-core==5.9.1
jupytext==1.19.5
kaggle==2.2.4
kagglesdk==0.1.37
markdown-it-py==4.2.0
MarkupSafe==3.0.3
mdit-py-plugins==0.6.1
mdurl==0.1.2
mpmath==1.3.0
nbformat==5.11.1
networkx==3.6.1
numpy==2.2.6
packaging==26.3
pandas==2.3.3
pillow==12.3.0
pip==26.0.1
platformdirs==4.11.3
protobuf==7.35.1
pyarrow==18.1.0
python-dateutil==2.9.0.post0
python-dotenv==1.2.3
python-slugify==8.0.4
pytz==2026.3.post1
PyYAML==6.0.3
referencing==0.37.0
reportlab==4.2.5
requests==2.34.2
rpds-py==2026.6.3
scikit-learn==1.7.2
scipy==1.15.3
setuptools==84.0.0

"""Shared public primitives for Yambda discovery-ranking evaluation.

Both the solver-visible validation evaluator and the private submission judge
import this module from the generated task's ``public`` directory. It owns the
stage-independent contract: reading a ranking, validating its shape, converting
it to per-user rank order, looking up packed candidate eligibility, and
computing graded NDCG@10.

The module deliberately contains no event-derived labels, private artifact
paths, or pass thresholds. Each evaluator supplies its own relevance data and
per-cutoff eligibility checks around these common operations.
"""
from __future__ import annotations

from pathlib import Path

import numpy as np
import pandas as pd


__all__ = [
    "CandidateSet",
    "QUALITY_K",
    "RankingValidationError",
    "REQUIRED_COLUMNS",
    "TOP_N",
    "ndcg_at_k",
    "ranked_items",
    "read_ranking",
    "score_rankings",
    "validate_ranking",
]

TOP_N = 100
QUALITY_K = 10
REQUIRED_COLUMNS = ("uid", "item_id", "rank")


class RankingValidationError(ValueError):
    """Report a ranking-schema or structural-contract violation."""


class CandidateSet:
    """Provide membership lookups over one packed candidate-set archive.

    The archive contains aligned ``uids``, ``item_ids``, and
    ``packed_eligible`` arrays. Candidate column ``c`` is represented by bit
    ``c % 8`` of byte ``c // 8`` using little-endian bit order. Arrays are
    copied into memory so they remain valid after the archive is closed.
    """

    def __init__(self, path: Path):
        """Load an eligibility archive and build ID-to-position indexes.

        Args:
            path: Path to a ``.npz`` archive with the candidate-set schema.
        """
        with np.load(path, allow_pickle=False) as artifact:
            self.uids = artifact["uids"].astype(np.int64, copy=True)
            self.item_ids = artifact["item_ids"].astype(np.int64, copy=True)
            self.packed = artifact["packed_eligible"].astype(np.uint8, copy=True)
        self.uid_row = {int(uid): row for row, uid in enumerate(self.uids)}
        self.item_column = {
            int(item): column for column, item in enumerate(self.item_ids)
        }

    def is_eligible(self, uid: int, item_id: int) -> bool:
        """Return whether ``item_id`` is eligible for ``uid``.

        IDs absent from the target-user or candidate-item arrays are treated as
        ineligible rather than raising an exception.

        Args:
            uid: Target user ID to query.
            item_id: Candidate item ID to query.

        Returns:
            ``True`` only when the corresponding packed eligibility bit is set.
        """
        row = self.uid_row.get(int(uid))
        column = self.item_column.get(int(item_id))
        if row is None or column is None:
            return False
        byte, bit = divmod(column, 8)
        return bool((int(self.packed[row, byte]) >> bit) & 1)


def read_ranking(path: Path) -> pd.DataFrame:
    """Read a parquet or CSV ranking into a pandas frame.

    Args:
        path: Input path. A ``.parquet`` suffix selects parquet; every other
            suffix is interpreted as CSV.

    Returns:
        The ranking frame as loaded by pandas.
    """
    return pd.read_parquet(path) if path.suffix == ".parquet" else pd.read_csv(path)


def validate_ranking(
    frame: pd.DataFrame,
    targets: set[int],
) -> pd.DataFrame:
    """Normalize and validate the stage-independent ranking contract.

    Required values must be finite integers. The user set must exactly match
    ``targets``; every user must have 100 rows, distinct items, and each rank
    from 1 through 100 exactly once. Cutoff-specific candidate eligibility is
    intentionally left to the calling evaluator.

    Args:
        frame: Raw ranking frame. Extra columns are discarded from an internal
            copy; the caller's frame is not modified.
        targets: Exact set of target user IDs the ranking must cover.

    Returns:
        A normalized frame containing only the required ``int64`` columns.

    Raises:
        RankingValidationError: If the ranking violates the shared contract.
    """
    required = list(REQUIRED_COLUMNS)
    if not all(column in frame for column in required):
        raise RankingValidationError(f"submission requires columns {required}")

    normalized = frame[required].copy()
    for column in required:
        numeric = pd.to_numeric(normalized[column], errors="coerce")
        values = numeric.to_numpy(dtype=float)
        if numeric.isna().any() or not np.isfinite(values).all():
            raise RankingValidationError(
                f"submission {column} must be finite numeric values"
            )
        if not np.equal(numeric, np.floor(numeric)).all():
            raise RankingValidationError(
                f"submission {column} must contain integers"
            )
        normalized[column] = numeric.astype(np.int64)

    submitted_users = set(map(int, normalized.uid.unique()))
    if submitted_users != targets:
        raise RankingValidationError(
            f"submission user set mismatch: missing={len(targets - submitted_users)} "
            f"extra={len(submitted_users - targets)}"
        )
    counts = normalized.groupby("uid").size()
    if not (counts == TOP_N).all():
        raise RankingValidationError(
            f"submission must contain exactly {TOP_N} rows for every target user"
        )
    if normalized.duplicated(["uid", "item_id"]).any():
        raise RankingValidationError(
            "submission contains duplicate (uid, item_id) pairs"
        )
    valid_ranks = set(range(1, TOP_N + 1))
    ranks_are_valid = normalized.groupby("uid")["rank"].apply(
        lambda values: set(map(int, values)) == valid_ranks
    )
    if not ranks_are_valid.all():
        raise RankingValidationError(
            f"each user must have every rank from 1 through {TOP_N} exactly once"
        )
    return normalized


def ranked_items(frame: pd.DataFrame) -> dict[int, list[int]]:
    """Convert a validated ranking frame to ordered items keyed by user.

    Args:
        frame: Frame that has passed :func:`validate_ranking`.

    Returns:
        A ``uid -> item IDs`` mapping ordered by ascending rank.
    """
    ordered = frame.sort_values(["uid", "rank"])
    return {
        int(uid): list(map(int, values))
        for uid, values in ordered.groupby("uid").item_id
    }


def ndcg_at_k(ranked: list[int], gold: dict[int, int], k: int) -> float:
    """Compute graded normalized discounted cumulative gain at ``k``.

    Relevance gain is ``2**grade - 1`` and the discount at one-based rank
    ``r`` is ``1 / log2(r + 1)``. Items absent from ``gold`` have grade zero.

    Args:
        ranked: Item IDs in predicted rank order.
        gold: Mapping from relevant item IDs to integer relevance grades.
        k: Maximum number of predicted positions to score.

    Returns:
        For a valid duplicate-free ranking, NDCG in ``[0, 1]``; returns
        ``0.0`` when the ideal gain is zero.
    """
    gains = np.asarray([gold.get(item, 0) for item in ranked[:k]], dtype=np.float64)
    discounts = 1.0 / np.log2(np.arange(2, len(gains) + 2))
    dcg = float(np.sum((np.power(2.0, gains) - 1.0) * discounts))
    ideal = np.asarray(sorted(gold.values(), reverse=True)[:k], dtype=np.float64)
    ideal_discounts = 1.0 / np.log2(np.arange(2, len(ideal) + 2))
    idcg = float(np.sum((np.power(2.0, ideal) - 1.0) * ideal_discounts))
    return dcg / idcg if idcg else 0.0


def score_rankings(
    ranked: dict[int, list[int]],
    graded: dict[int, dict[int, int]],
) -> dict[str, float | int]:
    """Aggregate per-user NDCG@10 over users with relevance labels.

    Args:
        ranked: Ranked item IDs for every target user.
        graded: Relevant item grades keyed by user and item.

    Returns:
        The six-decimal ``quality_ndcg@10`` value and number of scored users.
    """
    quality = float(
        np.mean(
            [
                ndcg_at_k(ranked[uid], gold, QUALITY_K)
                for uid, gold in graded.items()
            ]
        )
    )
    return {
        "quality_ndcg@10": round(quality, 6),
        "quality_users": len(graded),
    }

#!/usr/bin/env python3
"""Score a validation-stage ranking against public discovery labels.

``build_task.py`` publishes this module with the solver-visible task files. It
loads target users, validation eligibility, and validation-window events from
the adjacent ``data`` directory, then evaluates one ranking supplied on the
command line. Stage-independent mechanics come from the adjacent public
``ranking_evaluation.py`` module. The builder installs the same checked-in
module in the private judge, so public and private scoring mechanics cannot
drift. A relevant candidate receives grade 3 for an organic like or grade 1 for
an organic listen with at least 80 percent completion; a like takes precedence
when both events exist.

Before scoring, the ranking must contain exactly 100 distinct eligible items
for every target user, with integer-valued ``uid``, ``item_id``, and ``rank``
columns and ranks 1 through 100 exactly once per user. Extra columns are
ignored. Quality is graded NDCG@10, averaged only over users who have at least
one eligible relevant item in the validation window.

The evaluator prints a JSON object containing the model path and scores. It
does not apply the task's pass threshold; its purpose is model development and
selection. The private judge applies the threshold to the final submission.

Usage::

    python evaluate_public.py <validation-ranking.parquet|csv>
"""
from __future__ import annotations

import json
import sys
from pathlib import Path

import pandas as pd

from ranking_evaluation import (
    CandidateSet,
    RankingValidationError,
    ranked_items,
    read_ranking,
    score_rankings,
    validate_ranking,
)


HERE = Path(__file__).resolve().parent
DATA = HERE / "data"
LISTEN_STRONG = 80


def validation_truth(
    eligibility: CandidateSet, targets: set[int]
) -> dict[int, dict[int, int]]:
    """Build cutoff-correct graded relevance from public validation events.

    Only target-user events for eligible candidates are retained. Organic
    listens completed to at least 80 percent receive grade 1, and organic likes
    receive grade 3. Repeated user-item events are collapsed, and processing
    likes second ensures that grade 3 wins over grade 1.

    Args:
        eligibility: Validation-cutoff candidate membership service.
        targets: Complete set of target user IDs.

    Returns:
        A nested ``uid -> item_id -> grade`` mapping. Users without an eligible
        relevant event are omitted.
    """
    listens = pd.read_parquet(DATA / "val_listens.parquet")
    likes = pd.read_parquet(DATA / "val_likes.parquet")
    strong = listens[
        listens.uid.isin(targets)
        & (listens.is_organic == 1)
        & (listens.played_ratio_pct >= LISTEN_STRONG)
    ][["uid", "item_id"]].drop_duplicates()
    organic_likes = likes[
        likes.uid.isin(targets) & (likes.is_organic == 1)
    ][["uid", "item_id"]].drop_duplicates()

    graded: dict[int, dict[int, int]] = {}
    for raw_uid, raw_item in strong.itertuples(index=False, name=None):
        uid, item = int(raw_uid), int(raw_item)
        if eligibility.is_eligible(uid, item):
            graded.setdefault(uid, {})[item] = 1
    for raw_uid, raw_item in organic_likes.itertuples(index=False, name=None):
        uid, item = int(raw_uid), int(raw_item)
        if eligibility.is_eligible(uid, item):
            graded.setdefault(uid, {})[item] = 3
    return graded


def load_submission(
    path: Path, eligibility: CandidateSet, targets: set[int]
) -> dict[int, list[int]]:
    """Load and validate a public validation ranking.

    Files ending in ``.parquet`` are read as parquet; every other suffix is
    read as CSV. The required columns must be integer-valued, cover exactly the
    target-user set, contain 100 rows and ranks 1 through 100 per user, avoid
    duplicate user-item pairs, and contain only cutoff-eligible items.

    Args:
        path: Ranking file to read.
        eligibility: Validation-cutoff candidate membership service.
        targets: Exact set of users the ranking must cover.

    Returns:
        A ``uid -> ranked item IDs`` mapping ordered by ascending rank.

    Raises:
        ValueError: If the ranking violates the required schema or invariants.
    """
    frame = validate_ranking(read_ranking(path), targets)
    if not all(
        eligibility.is_eligible(uid, item)
        for uid, item in frame[["uid", "item_id"]].itertuples(index=False, name=None)
    ):
        raise RankingValidationError(
            "submission contains an item rejected by eligibility service"
        )
    return ranked_items(frame)


def score(
    ranked: dict[int, list[int]],
    graded: dict[int, dict[int, int]],
) -> dict[str, float | int]:
    """Aggregate per-user NDCG@10 over users with public relevance labels.

    Args:
        ranked: Ranked item IDs for every target user.
        graded: Eligible validation relevance keyed by user and item.

    Returns:
        The six-decimal ``quality_ndcg@10`` value and number of scored users.
    """
    return score_rankings(ranked, graded)


def main() -> None:
    """Run the public evaluator CLI and print its JSON score report."""
    targets_frame = pd.read_parquet(DATA / "target_users.parquet")
    targets = set(targets_frame.uid.astype(int))
    eligibility = CandidateSet(DATA / "validation_eligible_candidates.npz")
    graded = validation_truth(eligibility, targets)

    if len(sys.argv) != 2:
        raise SystemExit(
            "usage: evaluate_public.py <validation-ranking.parquet|csv>"
        )
    path = Path(sys.argv[1])
    ranked = load_submission(path, eligibility, targets)
    print(json.dumps({"model": str(path), "scores": score(ranked, graded)}, indent=2))


if __name__ == "__main__":
    main()

candidate_catalog (30000, 4) ['item_id', 'positive_listens', 'organic_positive_listens', 'popularity_rank']
   item_id  positive_listens  organic_positive_listens  popularity_rank
0  5862961             26615                     20620                1
1  6901374             25536                     17347                2
2  5635052             24691                     17194                3
target_users (8456, 3) ['uid', 'recent_positive_listens', 'history_positive_listens']
   uid  recent_positive_listens  history_positive_listens
0  100                    844.0                      2604
1  200                     50.0                       286
2  300                    168.0                       359
validation_preference_state (469124, 3) ['uid', 'item_id', 'state']
   uid  item_id  state
0  100   410868  liked
1  100   732449  liked
2  100   982903  liked
test_preference_state (484776, 3) ['uid', 'item_id', 'state']
   uid  item_id  state
0  100   410868  liked
1  100   732449  liked
2  100   982903  liked
<pyarrow._parquet.FileMetaData object at 0x78bdd1e72390>
  created_by: parquet-cpp-arrow version 18.1.0
  num_columns: 6
  num_rows: 43484159
  num_row_groups: 42
  format_version: 2.6
  serialized_size: 25540

               total        used        free      shared  buff/cache   available
Mem:              15           1           0           0          13          14
Swap:              0           0           0
8
2.8.0+cpu

{'uids': ((8456,), dtype('uint32')), 'item_ids': ((30000,), dtype('uint32')), 'packed_eligible': ((8456, 3750), dtype('uint8'))}
[29318 29832 29931 29320 28347 27476 29666 29501 28560 28736 29476 28476
 27836 27959 29626 29355 28904 28594 29529 29364] 29108.8

train (31249613, 5) 5.716594219207764
val (1011771, 5) 5.892027139663696
likes train (554824, 5)
likes val (21055, 5)
dislikes train (65321, 5)
dislikes val (2012, 5)
done 6.089343786239624

0 24786795
users 9217
val ts 24788600 25393395 7947
target in train users 0.9995269631031221
count    3.124961e+07
mean     6.550468e+01
std      4.389650e+01
min      0.000000e+00
25%      8.000000e+00
50%      1.000000e+02
75%      1.000000e+02
max      1.590000e+02
Name: played_ratio_pct, dtype: float64
organic frac 0.4998293578867681

same order True
100 682 allseen 682 pos 600 liked 13 dis 2
  inel-liked-dis 667 liked+dis not inel 0
  inel subset of seen? 0
200 168 allseen 168 pos 163 liked 0 dis 0
  inel-liked-dis 168 liked+dis not inel 0
  inel subset of seen? 0
800 2524 allseen 2524 pos 1910 liked 86 dis 14
  inel-liked-dis 2424 liked+dis not inel 0
  inel subset of seen? 0

events 31869758 9979 7.242335319519043
pairs 8054252 9.165929555892944
cut 24182000 4184 9.52771544456482
cut 23879600 8293 9.808139562606812
cut 23577200 12328 10.085317850112915
cut 23274800 16295 10.362085103988647
cut 22972400 20177 10.631194591522217
cut 22670000 23968 10.89437222480774
cut 22367600 27823 11.160430192947388
cut 22065200 31704 11.42930293083191
cut 21762800 35507 11.691993713378906
cut 21460400 39263 11.951335430145264
cut 21158000 42932 12.206868648529053
cut 20855600 46551 12.466639041900635
cut 20553200 50210 12.722816228866577
cut 20250800 53776 12.973493337631226
cut 19948400 57364 13.223674774169922
cut 19646000 60847 13.47585916519165
saved 60847 481369 17.281908750534058

ok

Command did not complete within its 120s timeout and was moved to the background (ID: bfetsbz4b). Output is being written to: /tmp/claude-1000/-app/746159f9-6934-411c-832b-430fa9886b51/tasks/bfetsbz4b.output. You will be notified when it completes. To check interim output, use Read on that file path.

ok
pairs 481369 examples 60847
ep0 loss 13.2226 129s
saved 129.19863605499268

[exited with code 0]

started

submission.parquet ok
total 258992
drwxr-xr-x 1 agent agent      4096 Aug 29 01:02 .
drwxr-xr-x 1 agent agent      4096 Aug 29 00:50 ..
-rw-r--r-- 1 agent agent 217770474 Aug 29 00:56 L_train.parquet
-rw-r--r-- 1 agent agent   5400977 Aug 29 00:56 L_val.parquet
-rw-r--r-- 1 agent agent      3869 Aug 29 00:57 build.py
-rw-r--r-- 1 agent agent   1014430 Aug 29 00:56 d_train.parquet
-rw-r--r-- 1 agent agent     38667 Aug 29 00:56 d_val.parquet
-rw-r--r-- 1 agent agent      2992 Aug 29 01:01 infer.py
-rw-r--r-- 1 agent agent    240128 Aug 29 00:55 items.npy
-rw-r--r-- 1 agent agent   6452661 Aug 29 00:56 l_train.parquet
-rw-r--r-- 1 agent agent    324512 Aug 29 00:56 l_val.parquet
-rw-r--r-- 1 agent agent        28 Aug 29 01:02 log_dev.txt
-rw-r--r-- 1 agent agent      2328 Aug 29 00:58 model.py
-rw-r--r-- 1 agent agent  15586015 Aug 29 01:00 model_dev.pt
-rw-r--r-- 1 agent agent      1509 Aug 29 00:55 prep.py
-rw-r--r-- 1 agent agent    735840 Aug 29 01:02 submission.parquet
-rw-r--r-- 1 agent agent      2102 Aug 29 01:02 train.py
-rw-r--r-- 1 agent agent  17586342 Aug 29 00:58 train_dev.npz

pairs 481369 examples 60847
ep0 loss 9.1428 72s

cut 20553200 58765 18.22291874885559
cut 20250800 62331 18.556025981903076
saved 62331 496725 23.13249659538269

Exit code 143
Command timed out after 2m 0s

pairs 481369 examples 60847
ep0 loss 9.1428 72s
ep1 loss 6.7475 164s
ep2 loss 5.1105 236s
ep3 loss 4.2862 308s

pairs 481369 examples 60847
ep0 loss 9.1428 72s
ep1 loss 6.7475 164s
ep2 loss 5.1105 236s
ep3 loss 4.2862 308s
ep4 loss 3.6791 381s
ep5 loss 3.1796 453s
ep6 loss 2.8427 525s
saved 524.9852547645569
launched_final

wrote validation.parquet (845600, 3) 4.3042497634887695
{
  "model": "validation.parquet",
  "scores": {
    "quality_ndcg@10": 0.014165,
    "quality_users": 4263
  }
}

{
  "model": "pop_val.parquet",
  "scores": {
    "quality_ndcg@10": 0.01071,
    "quality_users": 4263
  }
}

pairs 496725 examples 62331
ep0 loss 9.1245 99s

pairs 496725 examples 62331
ep0 loss 9.1245 99s
ep1 loss 6.7656 174s
ep2 loss 5.1505 249s

pairs 496725 examples 62331
ep0 loss 9.1245 99s
ep1 loss 6.7656 174s
ep2 loss 5.1505 249s
ep3 loss 4.3293 324s
ep4 loss 3.7280 399s
ep5 loss 3.2250 474s
ep6 loss 2.8903 549s
saved 549.1137042045593

wrote sub_tmp.parquet (845600, 3) 1.428253412246704
ineligible 0 rows 845600
submission written

total 76680
drwxr-xr-x 1 agent agent     4096 Aug 29 01:20 .
drwxr-xr-x 1 agent agent     4096 Aug 29 00:50 ..
-rw-r--r-- 1 agent agent     3281 Aug 29 01:12 README.md
-rw-r--r-- 1 agent agent     3869 Aug 29 00:57 build.py
-rw-r--r-- 1 agent agent  1014430 Aug 29 00:56 d_train.parquet
-rw-r--r-- 1 agent agent    38667 Aug 29 00:56 d_val.parquet
-rw-r--r-- 1 agent agent     2992 Aug 29 01:01 infer.py
-rw-r--r-- 1 agent agent   240128 Aug 29 00:55 items.npy
-rw-r--r-- 1 agent agent  6452661 Aug 29 00:56 l_train.parquet
-rw-r--r-- 1 agent agent   324512 Aug 29 00:56 l_val.parquet
-rw-r--r-- 1 agent agent      198 Aug 29 01:10 log_dev.txt
-rw-r--r-- 1 agent agent      198 Aug 29 01:20 log_final.txt
-rw-r--r-- 1 agent agent     2328 Aug 29 00:58 model.py
-rw-r--r-- 1 agent agent 15586015 Aug 29 01:10 model_dev.pt
-rw-r--r-- 1 agent agent 15586059 Aug 29 01:20 model_final.pt
-rw-r--r-- 1 agent agent     1509 Aug 29 00:55 prep.py
-rw-r--r-- 1 agent agent  1810207 Aug 29 01:20 submission.parquet
-rw-r--r-- 1 agent agent     2102 Aug 29 01:02 train.py
-rw-r--r-- 1 agent agent 17586342 Aug 29 00:58 train_dev.npz
-rw-r--r-- 1 agent agent 18004976 Aug 29 01:04 train_final.npz
-rw-r--r-- 1 agent agent  1809426 Aug 29 01:11 validation.parquet