diff --git a/tasks/0001_435_1435960_qa_4/task.toml b/tasks/0001_435_1435960_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d25124011d6e2bf71fec1b5c6e73b066c9a8bdac --- /dev/null +++ b/tasks/0001_435_1435960_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_435_1435960_qa_4" +description = "What is the average hours per week for individuals in the 'Federal-gov' workclass category?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/435/1435960.ipynb_qa_4" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "41.38" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "41.38" +QUESTION = "What is the average hours per week for individuals in the 'Federal-gov' workclass category?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_604_1604140_qa_5/instruction.md b/tasks/0001_604_1604140_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9c4ab4a4fb261b781217f791a43c58a4b56ef0d4 --- /dev/null +++ b/tasks/0001_604_1604140_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Mass Shootings Dataset Ver 2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average number of injured individuals per mass shooting incident according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_604_1604140_qa_5/task.toml b/tasks/0001_604_1604140_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cf4916c2ef792306bdc4072759cf64a7688c518c --- /dev/null +++ b/tasks/0001_604_1604140_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_604_1604140_qa_5" +description = "What is the average number of injured individuals per mass shooting incident according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/604/1604140.ipynb_qa_5" +kaggle_dataset_name = "zusmani/us-mass-shootings-last-50-years" +gold_answer = "6" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zusmani__us-mass-shootings-last-50-years" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zusmani/us-mass-shootings-last-50-years" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "What is the average number of injured individuals per mass shooting incident according to the dataset?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_668_1668567_qa_3/instruction.md b/tasks/0001_668_1668567_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0eaa368b32512f7a8415e3c25af31a0250513d86 --- /dev/null +++ b/tasks/0001_668_1668567_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique cereal manufacturers are represented in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_668_1668567_qa_3/task.toml b/tasks/0001_668_1668567_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..574310e9e4845a1b483ebcaa6228623e481181ee --- /dev/null +++ b/tasks/0001_668_1668567_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_668_1668567_qa_3" +description = "How many unique cereal manufacturers are represented in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/668/1668567.ipynb_qa_3" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "7" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7" +QUESTION = "How many unique cereal manufacturers are represented in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_840_1840182_qa_3/instruction.md b/tasks/0001_840_1840182_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a6ea7b7b0c92f4762d797416e29819da5efb3c97 --- /dev/null +++ b/tasks/0001_840_1840182_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winemag-data-130k-v2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which country is represented in the most expensive wines (highest price) in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_840_1840182_qa_3/task.toml b/tasks/0001_840_1840182_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8d9efb7a538759972f7b71228ad6d702c2d13766 --- /dev/null +++ b/tasks/0001_840_1840182_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_840_1840182_qa_3" +description = "Which country is represented in the most expensive wines (highest price) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/840/1840182.ipynb_qa_3" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "France" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "France" +QUESTION = "Which country is represented in the most expensive wines (highest price) in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_990_1990794_qa_5/instruction.md b/tasks/0001_990_1990794_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..49733e9582baef076e1bfd3d73d6777b0be2e9fd --- /dev/null +++ b/tasks/0001_990_1990794_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- 911_calls_for_service.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average number of 911 calls received per month in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_990_1990794_qa_5/task.toml b/tasks/0001_990_1990794_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bcef41bb7e3a7d73e0e40236a27fcc931460038f --- /dev/null +++ b/tasks/0001_990_1990794_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_990_1990794_qa_5" +description = "What is the average number of 911 calls received per month in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/990/1990794.ipynb_qa_5" +kaggle_dataset_name = "sohier/baltimore-911-calls" +gold_answer = "87497.31" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "sohier__baltimore-911-calls" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sohier/baltimore-911-calls" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "87497.31" +QUESTION = "What is the average number of 911 calls received per month in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0010_637_10637554_qa_1/instruction.md b/tasks/0010_637_10637554_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..92b66df158af3dbb04946b6e126a581cc441cafa --- /dev/null +++ b/tasks/0010_637_10637554_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winemag-data-130k-v2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which wine taster provided the highest average rating score in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0014_211_14211731_qa_3/instruction.md b/tasks/0014_211_14211731_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0b0aa7e83672759f2b81c13d2ed1ec250ff24ab2 --- /dev/null +++ b/tasks/0014_211_14211731_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the standard deviation of the number of axillary nodes in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0014_211_14211731_qa_3/task.toml b/tasks/0014_211_14211731_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..25b192ea5cbad1768b909660fcc274ce91013c9b --- /dev/null +++ b/tasks/0014_211_14211731_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0014_211_14211731_qa_3" +description = "What is the standard deviation of the number of axillary nodes in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/211/14211731.ipynb_qa_3" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "7.18" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7.18" +QUESTION = "What is the standard deviation of the number of axillary nodes in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0022_860_22860039_qa_1/instruction.md b/tasks/0022_860_22860039_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c74f6a4bf6c1ee9308e0d328f95347f60ef1cecb --- /dev/null +++ b/tasks/0022_860_22860039_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the Mushroom Classification dataset exhibits the strongest negative Pearson correlation with the 'class' attribute (edible/poisonous)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0022_860_22860039_qa_1/task.toml b/tasks/0022_860_22860039_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..584cfe8dda38afa955dc0d7ec5b67af0b5fcbd0a --- /dev/null +++ b/tasks/0022_860_22860039_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0022_860_22860039_qa_1" +description = "Which feature in the Mushroom Classification dataset exhibits the strongest negative Pearson correlation with the 'class' attribute (edible/poisonous)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0022/860/22860039.ipynb_qa_1" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "gill-color" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "gill-color" +QUESTION = "Which feature in the Mushroom Classification dataset exhibits the strongest negative Pearson correlation with the 'class' attribute (edible/poisonous)?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0025_024_25024460_qa_1/instruction.md b/tasks/0025_024_25024460_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6e98f6f2406a800103c24694c5a926d9bcdc5ba6 --- /dev/null +++ b/tasks/0025_024_25024460_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature is ranked as the most important by the Extra-Trees Regressor model in predicting insurance charges? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0025_024_25024460_qa_1/task.toml b/tasks/0025_024_25024460_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..80e79334d925c3fb5ec193534298c51898b868d6 --- /dev/null +++ b/tasks/0025_024_25024460_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0025_024_25024460_qa_1" +description = "Which feature is ranked as the most important by the Extra-Trees Regressor model in predicting insurance charges?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0025/024/25024460.ipynb_qa_1" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "smoker" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "smoker" +QUESTION = "Which feature is ranked as the most important by the Extra-Trees Regressor model in predicting insurance charges?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0030_471_30471502_qa_3/instruction.md b/tasks/0030_471_30471502_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a17fd643ccb2b20bd18664cce1cf5ef1c7704a23 --- /dev/null +++ b/tasks/0030_471_30471502_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many mushrooms in the dataset are classified as edible (class = 'e')? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0030_471_30471502_qa_3/task.toml b/tasks/0030_471_30471502_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6a2b58daa382a4ab5cbb69521f21e84bb5282219 --- /dev/null +++ b/tasks/0030_471_30471502_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0030_471_30471502_qa_3" +description = "How many mushrooms in the dataset are classified as edible (class = 'e')?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/471/30471502.ipynb_qa_3" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "4208" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4208" +QUESTION = "How many mushrooms in the dataset are classified as edible (class = 'e')?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0031_906_31906980_qa_1/instruction.md b/tasks/0031_906_31906980_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6bc50568d3b61ee7b6cb5345c01417f9d84ca551 --- /dev/null +++ b/tasks/0031_906_31906980_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- iris.data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the accuracy of the SVM classifier on the test set? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0031_906_31906980_qa_1/task.toml b/tasks/0031_906_31906980_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e23d90f2b9dd34c26b8409070b4ae9a64685a4f9 --- /dev/null +++ b/tasks/0031_906_31906980_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0031_906_31906980_qa_1" +description = "What is the accuracy of the SVM classifier on the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/906/31906980.ipynb_qa_1" +kaggle_dataset_name = "vikrishnan/iris-dataset" +gold_answer = "1.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "vikrishnan__iris-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vikrishnan/iris-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.0" +QUESTION = "What is the accuracy of the SVM classifier on the test set?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_945_32945624_qa_2/instruction.md b/tasks/0032_945_32945624_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dd184882a0be5354d6c530166df09b1b8e5361d5 --- /dev/null +++ b/tasks/0032_945_32945624_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +For the Iris-virginica species, which measured feature shows the least skewness in its distribution? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0032_945_32945624_qa_2/task.toml b/tasks/0032_945_32945624_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fb6f0c7166cadac4c8eddbafffdb0d6a2b5146d1 --- /dev/null +++ b/tasks/0032_945_32945624_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0032_945_32945624_qa_2" +description = "For the Iris-virginica species, which measured feature shows the least skewness in its distribution?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/945/32945624.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalWidthCm" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PetalWidthCm" +QUESTION = "For the Iris-virginica species, which measured feature shows the least skewness in its distribution?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_362_35362667_qa_4/instruction.md b/tasks/0035_362_35362667_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0dc9d047e5593e4763ef3efdeecba108b03bc1f1 --- /dev/null +++ b/tasks/0035_362_35362667_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which mushroom class (edible/poisonous) has the most imbalanced feature distribution in the 'stalk-root' attribute? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_362_35362667_qa_4/task.toml b/tasks/0035_362_35362667_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4c66f645d2e7e7c4d59791cfdbd89ff0b0d160a6 --- /dev/null +++ b/tasks/0035_362_35362667_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0035_362_35362667_qa_4" +description = "Which mushroom class (edible/poisonous) has the most imbalanced feature distribution in the 'stalk-root' attribute?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/362/35362667.ipynb_qa_4" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "edible" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "edible" +QUESTION = "Which mushroom class (edible/poisonous) has the most imbalanced feature distribution in the 'stalk-root' attribute?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_712_35712790_qa_3/instruction.md b/tasks/0035_712_35712790_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3709008796aead0d9fd11b82dae2286ff1bba3b9 --- /dev/null +++ b/tasks/0035_712_35712790_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- household_power_consumption.txt + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the p-value from the ADF test for the Global_intensity variable in the monthly aggregated data before any differencing was applied? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_712_35712790_qa_3/task.toml b/tasks/0035_712_35712790_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d69b23f76f2ea76e172a0e6999f55de86a198d26 --- /dev/null +++ b/tasks/0035_712_35712790_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_712_35712790_qa_3" +description = "What is the p-value from the ADF test for the Global_intensity variable in the monthly aggregated data before any differencing was applied?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/712/35712790.ipynb_qa_3" +kaggle_dataset_name = "uciml/electric-power-consumption-data-set" +gold_answer = "1.255263e-07" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__electric-power-consumption-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/electric-power-consumption-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.255263e-07" +QUESTION = "What is the p-value from the ADF test for the Global_intensity variable in the monthly aggregated data before any differencing was applied?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0038_681_38681339_qa_3/instruction.md b/tasks/0038_681_38681339_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7260a83b8348111361c9b4ea2d356c11d6813257 --- /dev/null +++ b/tasks/0038_681_38681339_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- bigml_59c28831336c6604c800002a.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which model demonstrated the best combination of high accuracy (over 94%) and acceptable recall (over 70%) for the churn prediction task? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0038_681_38681339_qa_3/task.toml b/tasks/0038_681_38681339_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0d7bedf4698e71e1919c0ed9eb697cd56dfb18a8 --- /dev/null +++ b/tasks/0038_681_38681339_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_681_38681339_qa_3" +description = "Which model demonstrated the best combination of high accuracy (over 94%) and acceptable recall (over 70%) for the churn prediction task?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/681/38681339.ipynb_qa_3" +kaggle_dataset_name = "becksddf/churn-in-telecoms-dataset" +gold_answer = "Gradient Boosting" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "becksddf__churn-in-telecoms-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "becksddf/churn-in-telecoms-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Gradient Boosting" +QUESTION = "Which model demonstrated the best combination of high accuracy (over 94%) and acceptable recall (over 70%) for the churn prediction task?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_785_40785152_qa_5/instruction.md b/tasks/0040_785_40785152_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8c34e2d96ad7c141a7ccb2446b32e25853dcfd80 --- /dev/null +++ b/tasks/0040_785_40785152_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the minimum value of 'fixed acidity' in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_785_40785152_qa_5/task.toml b/tasks/0040_785_40785152_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bf8d2aae0b50f42a6cf684c3d3689ee9e0c2607b --- /dev/null +++ b/tasks/0040_785_40785152_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0040_785_40785152_qa_5" +description = "What is the minimum value of 'fixed acidity' in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/785/40785152.ipynb_qa_5" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "4.6" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4.6" +QUESTION = "What is the minimum value of 'fixed acidity' in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_652_41652253_qa_1/instruction.md b/tasks/0041_652_41652253_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..aeab2cce5beb443c07bca65c9dfb28f0ef77b210 --- /dev/null +++ b/tasks/0041_652_41652253_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- column_2C_weka.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the coefficient of determination (R²) for the linear regression model predicting sacral slope from pelvic incidence? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_652_41652253_qa_1/task.toml b/tasks/0041_652_41652253_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..95ea17545bcd6b15c8ebc92513f598776d5a6b62 --- /dev/null +++ b/tasks/0041_652_41652253_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0041_652_41652253_qa_1" +description = "What is the coefficient of determination (R²) for the linear regression model predicting sacral slope from pelvic incidence?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/652/41652253.ipynb_qa_1" +kaggle_dataset_name = "uciml/biomechanical-features-of-orthopedic-patients" +gold_answer = "0.664159783972475" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__biomechanical-features-of-orthopedic-patients" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/biomechanical-features-of-orthopedic-patients" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.664159783972475" +QUESTION = "What is the coefficient of determination (R²) for the linear regression model predicting sacral slope from pelvic incidence?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0042_124_42124908_qa_1/instruction.md b/tasks/0042_124_42124908_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..06b0796cf1e26f3dd76cf66fdbc0ffb740368bd9 --- /dev/null +++ b/tasks/0042_124_42124908_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the predicted price for a house with 2000 sqft of living space using the Linear Regression model? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0042_124_42124908_qa_1/task.toml b/tasks/0042_124_42124908_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f159e802402b4d73a17a2585d2bd632c9377cf10 --- /dev/null +++ b/tasks/0042_124_42124908_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0042_124_42124908_qa_1" +description = "What is the predicted price for a house with 2000 sqft of living space using the Linear Regression model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/124/42124908.ipynb_qa_1" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "517666.39" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "517666.39" +QUESTION = "What is the predicted price for a house with 2000 sqft of living space using the Linear Regression model?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0045_006_45006527_qa_2/instruction.md b/tasks/0045_006_45006527_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4a4aea0a468d0b275adc1c2a55446061ef56e79f --- /dev/null +++ b/tasks/0045_006_45006527_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest correlation coefficient between any feature and the diabetes outcome (Outcome) in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0045_006_45006527_qa_2/task.toml b/tasks/0045_006_45006527_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..581cde223ef11365178f20e8830a0f1c77b9f0d3 --- /dev/null +++ b/tasks/0045_006_45006527_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0045_006_45006527_qa_2" +description = "What is the highest correlation coefficient between any feature and the diabetes outcome (Outcome) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/006/45006527.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0.466581" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.466581" +QUESTION = "What is the highest correlation coefficient between any feature and the diabetes outcome (Outcome) in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0052_041_52041171_qa_2/instruction.md b/tasks/0052_041_52041171_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e6d6cec82503b2393c98fdf96c59f41cab44e7fc --- /dev/null +++ b/tasks/0052_041_52041171_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the cluster assignment for the first five data points in the K-Means clustering model? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the cluster labels for the first five data points, in order. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0052_041_52041171_qa_2/task.toml b/tasks/0052_041_52041171_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..75cc00a38e61025596639cea82057ff179f1f41d --- /dev/null +++ b/tasks/0052_041_52041171_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0052_041_52041171_qa_2" +description = "What is the cluster assignment for the first five data points in the K-Means clustering model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0052/041/52041171.ipynb_qa_2" +kaggle_dataset_name = "kamrankausar/iris-data" +gold_answer = "1,1,1,1,1" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kamrankausar__iris-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kamrankausar/iris-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1,1,1,1,1" +QUESTION = "What is the cluster assignment for the first five data points in the K-Means clustering model?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0052_172_52172729_qa_2/instruction.md b/tasks/0052_172_52172729_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d42692a28a645c6db5ec7c92bee5c7d5a366cc03 --- /dev/null +++ b/tasks/0052_172_52172729_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of unique platforms remaining in the dataset after excluding the '2600' platform? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0052_172_52172729_qa_2/task.toml b/tasks/0052_172_52172729_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2c312424ed7672fdf85936f5bd5d63e1b3eb5dfb --- /dev/null +++ b/tasks/0052_172_52172729_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0052_172_52172729_qa_2" +description = "What is the total number of unique platforms remaining in the dataset after excluding the '2600' platform?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0052/172/52172729.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "30" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "30" +QUESTION = "What is the total number of unique platforms remaining in the dataset after excluding the '2600' platform?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0054_030_54030075_qa_5/instruction.md b/tasks/0054_030_54030075_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0607dc89c9e302a2664a97c0ddf0acca1d2dce6e --- /dev/null +++ b/tasks/0054_030_54030075_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the strongest correlation with the 'Outcome' variable in the dataset based on the correlation matrix? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0054_030_54030075_qa_5/task.toml b/tasks/0054_030_54030075_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1c993d56a7cbf82423fd71d8ae5d04c01ebf2190 --- /dev/null +++ b/tasks/0054_030_54030075_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0054_030_54030075_qa_5" +description = "What is the strongest correlation with the 'Outcome' variable in the dataset based on the correlation matrix?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0054/030/54030075.ipynb_qa_5" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Glucose" +QUESTION = "What is the strongest correlation with the 'Outcome' variable in the dataset based on the correlation matrix?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0055_474_55474406_qa_3/instruction.md b/tasks/0055_474_55474406_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8904adfa0b1cbec07df80bf4f9d497bbf38cc32f --- /dev/null +++ b/tasks/0055_474_55474406_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference in precision between the baseline model and the model with a maximum depth of 4 for the "edible" class in the test set? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0055_474_55474406_qa_3/task.toml b/tasks/0055_474_55474406_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0c609193de2e05b2db2ce305c696234397327df4 --- /dev/null +++ b/tasks/0055_474_55474406_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0055_474_55474406_qa_3" +description = "What is the difference in precision between the baseline model and the model with a maximum depth of 4 for the \"edible\" class in the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0055/474/55474406.ipynb_qa_3" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "0.02" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.02" +QUESTION = "What is the difference in precision between the baseline model and the model with a maximum depth of 4 for the \"edible\" class in the test set?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0056_414_56414713_qa_1/instruction.md b/tasks/0056_414_56414713_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f57a36bb3006ce4398addac4a7efc311a8239818 --- /dev/null +++ b/tasks/0056_414_56414713_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest upper whisker value for the 'alcohol' feature across all wine quality classes based on the outlier analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0056_414_56414713_qa_1/task.toml b/tasks/0056_414_56414713_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6ec350db01cb6cecd682a16a7f650b5103e0efa1 --- /dev/null +++ b/tasks/0056_414_56414713_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0056_414_56414713_qa_1" +description = "What is the highest upper whisker value for the 'alcohol' feature across all wine quality classes based on the outlier analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/414/56414713.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "14.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "14.0" +QUESTION = "What is the highest upper whisker value for the 'alcohol' feature across all wine quality classes based on the outlier analysis?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0056_714_56714045_qa_3/instruction.md b/tasks/0056_714_56714045_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e03befa7aaf5129fc26958bfac1f9bc0ad2d4104 --- /dev/null +++ b/tasks/0056_714_56714045_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After applying the outlier replacement thresholds, how many columns still had outliers remaining in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0056_714_56714045_qa_3/task.toml b/tasks/0056_714_56714045_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..85df70a9ea34ef0499e032c7c3beffcbfa9c95c5 --- /dev/null +++ b/tasks/0056_714_56714045_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0056_714_56714045_qa_3" +description = "After applying the outlier replacement thresholds, how many columns still had outliers remaining in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/714/56714045.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "After applying the outlier replacement thresholds, how many columns still had outliers remaining in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0062_251_62251582_qa_3/instruction.md b/tasks/0062_251_62251582_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7b09917c6eec34dad09b72cd92d04522f2edd7f8 --- /dev/null +++ b/tasks/0062_251_62251582_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- CC GENERAL.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After data preprocessing, how many numerical features were retained for analysis in the final dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0062_251_62251582_qa_3/task.toml b/tasks/0062_251_62251582_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dd3d547c480e77aae0e28fb81093532eac7a4614 --- /dev/null +++ b/tasks/0062_251_62251582_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0062_251_62251582_qa_3" +description = "After data preprocessing, how many numerical features were retained for analysis in the final dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0062/251/62251582.ipynb_qa_3" +kaggle_dataset_name = "arjunbhasin2013/ccdata" +gold_answer = "17" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "arjunbhasin2013__ccdata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arjunbhasin2013/ccdata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "17" +QUESTION = "After data preprocessing, how many numerical features were retained for analysis in the final dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0062_755_62755543_qa_2/instruction.md b/tasks/0062_755_62755543_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..632c3de525501d308bb65e183fba5f4a03ac4df3 --- /dev/null +++ b/tasks/0062_755_62755543_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many missing values were present in the 'Insulin' column after replacing zero values with NaNs? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0062_755_62755543_qa_2/task.toml b/tasks/0062_755_62755543_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..853c8df5909bef6d2298d6fbb2f8714c6de993e5 --- /dev/null +++ b/tasks/0062_755_62755543_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0062_755_62755543_qa_2" +description = "How many missing values were present in the 'Insulin' column after replacing zero values with NaNs?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0062/755/62755543.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "374" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "374" +QUESTION = "How many missing values were present in the 'Insulin' column after replacing zero values with NaNs?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0067_241_67241146_qa_2/instruction.md b/tasks/0067_241_67241146_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..25e2d792997485b8bf7090ff6382a6816abd86f0 --- /dev/null +++ b/tasks/0067_241_67241146_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many patients were removed from the dataset due to duplicate records during the cleaning process? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0067_241_67241146_qa_2/task.toml b/tasks/0067_241_67241146_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..425b60fa712d107cb115731a4c66f64637a11c8f --- /dev/null +++ b/tasks/0067_241_67241146_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0067_241_67241146_qa_2" +description = "How many patients were removed from the dataset due to duplicate records during the cleaning process?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/241/67241146.ipynb_qa_2" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "17" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "17" +QUESTION = "How many patients were removed from the dataset due to duplicate records during the cleaning process?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0067_290_67290658_qa_1/instruction.md b/tasks/0067_290_67290658_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..69e03b1f566a4f557d0d133c82bb904fa9e2fe27 --- /dev/null +++ b/tasks/0067_290_67290658_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- survey.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the relationship between having health benefits and seeking treatment for mental health issues statistically significant? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0067_290_67290658_qa_1/task.toml b/tasks/0067_290_67290658_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e5592e0d3b5eb0409e157f116649013841569811 --- /dev/null +++ b/tasks/0067_290_67290658_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0067_290_67290658_qa_1" +description = "Is the relationship between having health benefits and seeking treatment for mental health issues statistically significant?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/290/67290658.ipynb_qa_1" +kaggle_dataset_name = "osmi/mental-health-in-tech-survey" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "osmi__mental-health-in-tech-survey" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "osmi/mental-health-in-tech-survey" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the relationship between having health benefits and seeking treatment for mental health issues statistically significant?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0069_119_69119898_qa_1/instruction.md b/tasks/0069_119_69119898_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..53331f4c0604e72bf2fdc4e1cb01d1d9536adc12 --- /dev/null +++ b/tasks/0069_119_69119898_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which passenger class has the highest frequency in the dataset according to the Apriori algorithm results? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0069_119_69119898_qa_1/task.toml b/tasks/0069_119_69119898_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b8af10448d572e50ad30a380c13132aec8ba8b70 --- /dev/null +++ b/tasks/0069_119_69119898_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0069_119_69119898_qa_1" +description = "Which passenger class has the highest frequency in the dataset according to the Apriori algorithm results?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0069/119/69119898.ipynb_qa_1" +kaggle_dataset_name = "harunshimanto/titanic-solution-a-beginners-guide" +gold_answer = "3" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harunshimanto__titanic-solution-a-beginners-guide" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harunshimanto/titanic-solution-a-beginners-guide" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "Which passenger class has the highest frequency in the dataset according to the Apriori algorithm results?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0075_210_75210599_qa_3/instruction.md b/tasks/0075_210_75210599_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fbeae06c2d3148c8fcc334197fa385c577ceba0e --- /dev/null +++ b/tasks/0075_210_75210599_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many features in the dataset have a Variance Inflation Factor (VIF) exceeding 10,000, indicating extreme multicollinearity? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0075_210_75210599_qa_3/task.toml b/tasks/0075_210_75210599_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..68ef70229c2ebe9d8af95c1bd89c937d32592174 --- /dev/null +++ b/tasks/0075_210_75210599_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0075_210_75210599_qa_3" +description = "How many features in the dataset have a Variance Inflation Factor (VIF) exceeding 10,000, indicating extreme multicollinearity?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/210/75210599.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "2" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "How many features in the dataset have a Variance Inflation Factor (VIF) exceeding 10,000, indicating extreme multicollinearity?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0077_965_77965722_qa_2/instruction.md b/tasks/0077_965_77965722_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d0e53c4d17dae5a0b88b12142902d4dae2980840 --- /dev/null +++ b/tasks/0077_965_77965722_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which regularization parameter value achieved the lowest validation RMSE in the hyperparameter tuning experiment? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0077_965_77965722_qa_2/task.toml b/tasks/0077_965_77965722_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a10c957cd130ba13223c39541e82b188072096e3 --- /dev/null +++ b/tasks/0077_965_77965722_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0077_965_77965722_qa_2" +description = "Which regularization parameter value achieved the lowest validation RMSE in the hyperparameter tuning experiment?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/965/77965722.ipynb_qa_2" +kaggle_dataset_name = "CooperUnion/cardataset" +gold_answer = "0.00001" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "CooperUnion__cardataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "CooperUnion/cardataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.00001" +QUESTION = "Which regularization parameter value achieved the lowest validation RMSE in the hyperparameter tuning experiment?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0083_022_83022280_qa_3/task.toml b/tasks/0083_022_83022280_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..642960510346be1ffbfa4e059887db478e871ef4 --- /dev/null +++ b/tasks/0083_022_83022280_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0083_022_83022280_qa_3" +description = "What percentage of the dataset was allocated to the test set during the train-test split for model evaluation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0083/022/83022280.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "20" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "20" +QUESTION = "What percentage of the dataset was allocated to the test set during the train-test split for model evaluation?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0084_953_84953718_qa_1/instruction.md b/tasks/0084_953_84953718_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4db270f393d50782cc7c44fb176390e6633750a1 --- /dev/null +++ b/tasks/0084_953_84953718_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the threshold value of axillary nodes where the cumulative probability of survival exceeds 80% for patients surviving more than 5 years? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0084_953_84953718_qa_1/task.toml b/tasks/0084_953_84953718_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d1f1f872883113fbbc899a279fed3e155f40d52b --- /dev/null +++ b/tasks/0084_953_84953718_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0084_953_84953718_qa_1" +description = "What is the threshold value of axillary nodes where the cumulative probability of survival exceeds 80% for patients surviving more than 5 years?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/953/84953718.ipynb_qa_1" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "4" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "What is the threshold value of axillary nodes where the cumulative probability of survival exceeds 80% for patients surviving more than 5 years?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0085_618_85618243_qa_2/instruction.md b/tasks/0085_618_85618243_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..22cd3430b7a14b52e610021449cb3ee02719099b --- /dev/null +++ b/tasks/0085_618_85618243_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique zipcodes in the dataset have more than 100 entries after filtering? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0085_618_85618243_qa_2/task.toml b/tasks/0085_618_85618243_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..630c5b2898612e0c15d9fec5c69fbce30e8ce8b3 --- /dev/null +++ b/tasks/0085_618_85618243_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0085_618_85618243_qa_2" +description = "How many unique zipcodes in the dataset have more than 100 entries after filtering?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0085/618/85618243.ipynb_qa_2" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "66" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "66" +QUESTION = "How many unique zipcodes in the dataset have more than 100 entries after filtering?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0092_008_92008043_qa_2/instruction.md b/tasks/0092_008_92008043_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ffebe15315b8be99180ea1446dfc0c710d53e3cb --- /dev/null +++ b/tasks/0092_008_92008043_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train_and_test2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the preprocessed dataset was allocated to the test set after splitting with a test size of 0.3? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0092_008_92008043_qa_2/task.toml b/tasks/0092_008_92008043_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..43def8cbf35dbf4c8cfd54b1b792b7e633088bba --- /dev/null +++ b/tasks/0092_008_92008043_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0092_008_92008043_qa_2" +description = "What percentage of the preprocessed dataset was allocated to the test set after splitting with a test size of 0.3?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0092/008/92008043.ipynb_qa_2" +kaggle_dataset_name = "heptapod/titanic" +gold_answer = "30" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "heptapod__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "heptapod/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "30" +QUESTION = "What percentage of the preprocessed dataset was allocated to the test set after splitting with a test size of 0.3?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0095_666_95666563_qa_5/instruction.md b/tasks/0095_666_95666563_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bd98b6d76e53090dc97b52bd6052d54b86250e7c --- /dev/null +++ b/tasks/0095_666_95666563_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the dataset consists of spam messages based on the original data distribution? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0095_666_95666563_qa_5/task.toml b/tasks/0095_666_95666563_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b5f8049fce75ce149b0fdc564995de1c862a5dbb --- /dev/null +++ b/tasks/0095_666_95666563_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0095_666_95666563_qa_5" +description = "What percentage of the dataset consists of spam messages based on the original data distribution?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/666/95666563.ipynb_qa_5" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "13.4" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__sms-spam-collection-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "13.4" +QUESTION = "What percentage of the dataset consists of spam messages based on the original data distribution?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0095_877_95877877_qa_3/instruction.md b/tasks/0095_877_95877877_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2530fee3d5c39c6ea0ffc46c6ed287fb8e643b4d --- /dev/null +++ b/tasks/0095_877_95877877_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- KaggleV2-May-2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which day of the week has the highest proportion of patients showing up for their appointments? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0095_877_95877877_qa_3/task.toml b/tasks/0095_877_95877877_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..40d3f2410c22e8f5f947fc504705fe85f0ec7b37 --- /dev/null +++ b/tasks/0095_877_95877877_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0095_877_95877877_qa_3" +description = "Which day of the week has the highest proportion of patients showing up for their appointments?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/877/95877877.ipynb_qa_3" +kaggle_dataset_name = "joniarroba/noshowappointments" +gold_answer = "Thursday" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "joniarroba__noshowappointments" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "joniarroba/noshowappointments" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Thursday" +QUESTION = "Which day of the week has the highest proportion of patients showing up for their appointments?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0100_171_100171054_qa_4/instruction.md b/tasks/0100_171_100171054_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c2d36f1edfb01fd74467535d512e7eefa42bcd7e --- /dev/null +++ b/tasks/0100_171_100171054_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- 50_Startups.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the p-value for the Administration variable in the multiple regression model including all three predictors (R&D Spend, Administration, Marketing Spend)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0100_171_100171054_qa_4/task.toml b/tasks/0100_171_100171054_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a5610b017d3dd6cdffed63606fbd195f2e2d9b8a --- /dev/null +++ b/tasks/0100_171_100171054_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0100_171_100171054_qa_4" +description = "What is the p-value for the Administration variable in the multiple regression model including all three predictors (R&D Spend, Administration, Marketing Spend)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0100/171/100171054.ipynb_qa_4" +kaggle_dataset_name = "karthickveerakumar/startup-logistic-regression" +gold_answer = "0.602" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "karthickveerakumar__startup-logistic-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "karthickveerakumar/startup-logistic-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.602" +QUESTION = "What is the p-value for the Administration variable in the multiple regression model including all three predictors (R&D Spend, Administration, Marketing Spend)?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0107_868_107868150_qa_1/instruction.md b/tasks/0107_868_107868150_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8d8c44d53bdd4e165e7921b191b9bd90d4e9fca3 --- /dev/null +++ b/tasks/0107_868_107868150_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest mutual information score with the diagnosis label in the breast cancer dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0107_868_107868150_qa_1/task.toml b/tasks/0107_868_107868150_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2e8a920f65e8117d741ee65750f7b058613aafcb --- /dev/null +++ b/tasks/0107_868_107868150_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0107_868_107868150_qa_1" +description = "Which feature has the highest mutual information score with the diagnosis label in the breast cancer dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0107/868/107868150.ipynb_qa_1" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "perimeter_worst" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "perimeter_worst" +QUESTION = "Which feature has the highest mutual information score with the diagnosis label in the breast cancer dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0108_225_108225204_qa_1/instruction.md b/tasks/0108_225_108225204_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..43f4085c6d0c306933f766ac4fc394d7d1509b25 --- /dev/null +++ b/tasks/0108_225_108225204_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the optimal number of clusters identified by the elbow method for the KMeans clustering on the Iris dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0108_225_108225204_qa_1/task.toml b/tasks/0108_225_108225204_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b9440460dc2f608cb5f4e56502d4312c9f56a39f --- /dev/null +++ b/tasks/0108_225_108225204_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0108_225_108225204_qa_1" +description = "What is the optimal number of clusters identified by the elbow method for the KMeans clustering on the Iris dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0108/225/108225204.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "3" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "What is the optimal number of clusters identified by the elbow method for the KMeans clustering on the Iris dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0108_588_108588873_qa_2/instruction.md b/tasks/0108_588_108588873_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..65f13b44581b6a43a2e4a6829d28a3fc4fcc8e49 --- /dev/null +++ b/tasks/0108_588_108588873_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median value of the wine quality scores in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0108_588_108588873_qa_2/task.toml b/tasks/0108_588_108588873_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b7961f06fa893c1cbad85e9b6770ada0c4d6e43c --- /dev/null +++ b/tasks/0108_588_108588873_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0108_588_108588873_qa_2" +description = "What is the median value of the wine quality scores in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0108/588/108588873.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "6" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "What is the median value of the wine quality scores in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0109_422_109422676_qa_3/instruction.md b/tasks/0109_422_109422676_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dddd456d291d5aa0fe00438417987a0ae844d78d --- /dev/null +++ b/tasks/0109_422_109422676_qa_3/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the price range of diamonds in the dataset (minimum to maximum)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated pair: , (plain numbers, no labels). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0109_422_109422676_qa_3/task.toml b/tasks/0109_422_109422676_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..10505e781b0ffb2179477cf01b8afbb6466db0e0 --- /dev/null +++ b/tasks/0109_422_109422676_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0109_422_109422676_qa_3" +description = "What is the price range of diamonds in the dataset (minimum to maximum)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0109/422/109422676.ipynb_qa_3" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "326, 18823" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "326, 18823" +QUESTION = "What is the price range of diamonds in the dataset (minimum to maximum)?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0111_875_111875662_qa_5/instruction.md b/tasks/0111_875_111875662_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..15d1bdcf3a154227e5633d1e6630bf5bacfb0039 --- /dev/null +++ b/tasks/0111_875_111875662_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the standard deviation of global sales values in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0111_875_111875662_qa_5/task.toml b/tasks/0111_875_111875662_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fa3f410a8120e2d1bad027650494f40523d229cd --- /dev/null +++ b/tasks/0111_875_111875662_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0111_875_111875662_qa_5" +description = "What is the standard deviation of global sales values in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0111/875/111875662.ipynb_qa_5" +kaggle_dataset_name = "kedokedokedo/vgsales" +gold_answer = "1.5658596703325405" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kedokedokedo__vgsales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kedokedokedo/vgsales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.5658596703325405" +QUESTION = "What is the standard deviation of global sales values in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0116_992_116992800_qa_2/instruction.md b/tasks/0116_992_116992800_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..87fba343e0fbf43e64694f38d49184c17b9d928b --- /dev/null +++ b/tasks/0116_992_116992800_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Does the mushroom dataset contain any missing values? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0116_992_116992800_qa_2/task.toml b/tasks/0116_992_116992800_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..89e82d46a12b36050794869ebfaa10882272d1e6 --- /dev/null +++ b/tasks/0116_992_116992800_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0116_992_116992800_qa_2" +description = "Does the mushroom dataset contain any missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0116/992/116992800.ipynb_qa_2" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "no" +reward_mode_initial = "exact_bool" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "no" +QUESTION = "Does the mushroom dataset contain any missing values?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0118_014_118014024_qa_4/task.toml b/tasks/0118_014_118014024_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..30085e74f77e583bcfbf24222bfc5fc38f49ff2f --- /dev/null +++ b/tasks/0118_014_118014024_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0118_014_118014024_qa_4" +description = "What is the median BMI value in the Pima Indians Diabetes dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0118/014/118014024.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "32.0" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "32.0" +QUESTION = "What is the median BMI value in the Pima Indians Diabetes dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0119_896_119896768_qa_3/instruction.md b/tasks/0119_896_119896768_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7f6d0007483a2765923f918e900612c60a3afbe8 --- /dev/null +++ b/tasks/0119_896_119896768_qa_3/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- parks.csv +- species.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common conservation status among species in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0119_896_119896768_qa_3/task.toml b/tasks/0119_896_119896768_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a04a291799855ea248b8a60a12343ccd8bf767c9 --- /dev/null +++ b/tasks/0119_896_119896768_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0119_896_119896768_qa_3" +description = "What is the most common conservation status among species in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0119/896/119896768.ipynb_qa_3" +kaggle_dataset_name = "nationalparkservice/park-biodiversity" +gold_answer = "Species of Concern" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "nationalparkservice__park-biodiversity" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nationalparkservice/park-biodiversity" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Species of Concern" +QUESTION = "What is the most common conservation status among species in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0125_554_125554588_qa_1/instruction.md b/tasks/0125_554_125554588_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1e135b02f7d051485540c72464264b0d48bbb68a --- /dev/null +++ b/tasks/0125_554_125554588_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the optimal lambda value determined by the Box-Cox transformation applied to the target variable (MEDV) in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0125_554_125554588_qa_1/task.toml b/tasks/0125_554_125554588_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..20199d1ec12ccb847876f5d1863a6c5b293cd576 --- /dev/null +++ b/tasks/0125_554_125554588_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0125_554_125554588_qa_1" +description = "What is the optimal lambda value determined by the Box-Cox transformation applied to the target variable (MEDV) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0125/554/125554588.ipynb_qa_1" +kaggle_dataset_name = "vikrishnan/boston-house-prices" +gold_answer = "0.2166209012915364" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "vikrishnan__boston-house-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vikrishnan/boston-house-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.2166209012915364" +QUESTION = "What is the optimal lambda value determined by the Box-Cox transformation applied to the target variable (MEDV) in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0128_485_128485352_qa_1/instruction.md b/tasks/0128_485_128485352_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1e20690a5de266148b86717086894fce373c4721 --- /dev/null +++ b/tasks/0128_485_128485352_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature was identified as the most important based on the Random Forest model's feature importance scores? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0128_485_128485352_qa_1/task.toml b/tasks/0128_485_128485352_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..be6cccad11641fab39d856b5a8b2752095c1be2e --- /dev/null +++ b/tasks/0128_485_128485352_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0128_485_128485352_qa_1" +description = "Which feature was identified as the most important based on the Random Forest model's feature importance scores?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0128/485/128485352.ipynb_qa_1" +kaggle_dataset_name = "elikplim/car-evaluation-data-set" +gold_answer = "safety" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "elikplim__car-evaluation-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "elikplim/car-evaluation-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "safety" +QUESTION = "Which feature was identified as the most important based on the Random Forest model's feature importance scores?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0131_881_131881806_qa_4/instruction.md b/tasks/0131_881_131881806_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0e86b835d553b8b57bfcbfe409d5a66dc703a9f9 --- /dev/null +++ b/tasks/0131_881_131881806_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common transmission type in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0131_881_131881806_qa_4/task.toml b/tasks/0131_881_131881806_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a2077a2166827dac1512c39b3109c4faee829d95 --- /dev/null +++ b/tasks/0131_881_131881806_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0131_881_131881806_qa_4" +description = "What is the most common transmission type in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0131/881/131881806.ipynb_qa_4" +kaggle_dataset_name = "CooperUnion/cardataset" +gold_answer = "AUTOMATIC" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "CooperUnion__cardataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "CooperUnion/cardataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "AUTOMATIC" +QUESTION = "What is the most common transmission type in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0135_043_135043306_qa_2/instruction.md b/tasks/0135_043_135043306_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..038615f05706fabdb8393ec7abd38abd5bdf7809 --- /dev/null +++ b/tasks/0135_043_135043306_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest total transaction amount (quantity × unit price) recorded in a single invoice in the cleaned dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0135_043_135043306_qa_2/task.toml b/tasks/0135_043_135043306_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6c7f0e5372ea174f79b366a7eb88de8aac7be240 --- /dev/null +++ b/tasks/0135_043_135043306_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0135_043_135043306_qa_2" +description = "What is the highest total transaction amount (quantity × unit price) recorded in a single invoice in the cleaned dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0135/043/135043306.ipynb_qa_2" +kaggle_dataset_name = "carrie1/ecommerce-data" +gold_answer = "168469.60" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "carrie1__ecommerce-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "carrie1/ecommerce-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "168469.60" +QUESTION = "What is the highest total transaction amount (quantity × unit price) recorded in a single invoice in the cleaned dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0136_198_136198797_qa_1/instruction.md b/tasks/0136_198_136198797_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0d0105895723b56649191740fe2f4ee77c17ff77 --- /dev/null +++ b/tasks/0136_198_136198797_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After encoding the ocean_proximity categories as dummy variables, how many unique categories are represented in the training data? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0136_198_136198797_qa_1/task.toml b/tasks/0136_198_136198797_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0c79a8a9879569708abed6dd3a0861c6555e6dc9 --- /dev/null +++ b/tasks/0136_198_136198797_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0136_198_136198797_qa_1" +description = "After encoding the ocean_proximity categories as dummy variables, how many unique categories are represented in the training data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0136/198/136198797.ipynb_qa_1" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5" +QUESTION = "After encoding the ocean_proximity categories as dummy variables, how many unique categories are represented in the training data?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env]