diff --git a/tasks/0000_526_526258_qa_2/instruction.md b/tasks/0000_526_526258_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1e7b414462f9143790092032b73552f2e256dbd7 --- /dev/null +++ b/tasks/0000_526_526258_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): +- AguaH.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many entries are categorized into the non-NA group, edge-NA group, and interrupted group based on missing value patterns? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the three counts in the order: non-NA, edge-NA, interrupted. + +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/0000_526_526258_qa_2/task.toml b/tasks/0000_526_526258_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e14c41a93579302169df9a3a41140fee07663a12 --- /dev/null +++ b/tasks/0000_526_526258_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0000_526_526258_qa_2" +description = "How many entries are categorized into the non-NA group, edge-NA group, and interrupted group based on missing value patterns?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/526/526258.ipynb_qa_2" +kaggle_dataset_name = "marcomolina/water-consumption-in-a-median-size-city" +gold_answer = "141205, 32568, 4824" +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 = "marcomolina__water-consumption-in-a-median-size-city" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "marcomolina/water-consumption-in-a-median-size-city" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "141205, 32568, 4824" +QUESTION = "How many entries are categorized into the non-NA group, edge-NA group, and interrupted group based on missing value patterns?" +REWARD_MODE = "list_csv" +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/0000_780_780974_qa_4/instruction.md b/tasks/0000_780_780974_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6c05904d566157e6632b52ed9c70ed73ed1655da --- /dev/null +++ b/tasks/0000_780_780974_qa_4/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): +- arrests.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the maximum number of arrests recorded at the Southwest border and in which year? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, numeric value first, year as a four-digit number). + +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/0000_780_780974_qa_4/task.toml b/tasks/0000_780_780974_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..81c540cad23ef7080428368742106d3ae9e0f75c --- /dev/null +++ b/tasks/0000_780_780974_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0000_780_780974_qa_4" +description = "What was the maximum number of arrests recorded at the Southwest border and in which year?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/780/780974.ipynb_qa_4" +kaggle_dataset_name = "cbp/illegal-immigrants" +gold_answer = "1643679 in 2000" +reward_mode_initial = "list" +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 = "cbp__illegal-immigrants" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "cbp/illegal-immigrants" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1643679 in 2000" +QUESTION = "What was the maximum number of arrests recorded at the Southwest border and in which year?" +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/0001_085_1085629_qa_2/instruction.md b/tasks/0001_085_1085629_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a59b3785c7abf7bad711b40f658b5929da5534f3 --- /dev/null +++ b/tasks/0001_085_1085629_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What are the top three features according to the feature importance ranking provided by the Extra Trees Classifier? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact feature names. + +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_085_1085629_qa_2/task.toml b/tasks/0001_085_1085629_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a5b734d3b6864d33dee59f4fa8cc918de3a76a63 --- /dev/null +++ b/tasks/0001_085_1085629_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_085_1085629_qa_2" +description = "What are the top three features according to the feature importance ranking provided by the Extra Trees Classifier?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/085/1085629.ipynb_qa_2" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "fnlwgt, age, hours.per.week" +reward_mode_initial = "list" +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 = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "fnlwgt, age, hours.per.week" +QUESTION = "What are the top three features according to the feature importance ranking provided by the Extra Trees Classifier?" +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/0001_133_1133625_qa_4/instruction.md b/tasks/0001_133_1133625_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..839922d1e63a7bd65764e2ebf84d15bf48c4e314 --- /dev/null +++ b/tasks/0001_133_1133625_qa_4/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): +- up_res.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +In which phase did BJP+ achieve the highest percentage of total votes, and what was that percentage? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, phase first, percentage with two decimals). + +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_133_1133625_qa_4/task.toml b/tasks/0001_133_1133625_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..73a0a80b236beb7bf793401bd836cb7215d039b8 --- /dev/null +++ b/tasks/0001_133_1133625_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_133_1133625_qa_4" +description = "In which phase did BJP+ achieve the highest percentage of total votes, and what was that percentage?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/133/1133625.ipynb_qa_4" +kaggle_dataset_name = "ankit2106/uttar-pradesh-assembly-elections-2017" +gold_answer = "Phase 1, 45.48" +reward_mode_initial = "list" +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 = "ankit2106__uttar-pradesh-assembly-elections-2017" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ankit2106/uttar-pradesh-assembly-elections-2017" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Phase 1, 45.48" +QUESTION = "In which phase did BJP+ achieve the highest percentage of total votes, and what was that percentage?" +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/0001_160_1160639_qa_1/instruction.md b/tasks/0001_160_1160639_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..14ce851c16eac777e4c89664c27e7447057f1f2d --- /dev/null +++ b/tasks/0001_160_1160639_qa_1/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): +- banknifty.csv +- nifty50.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average opening price of Nifty 50 across all recorded dates 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_160_1160639_qa_1/task.toml b/tasks/0001_160_1160639_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ef7bf2aa646d03839fd5d4e95e4cd09bb9c4749c --- /dev/null +++ b/tasks/0001_160_1160639_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_160_1160639_qa_1" +description = "What is the average opening price of Nifty 50 across all recorded dates in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/160/1160639.ipynb_qa_1" +kaggle_dataset_name = "ramamet4/nse-stocks-database" +gold_answer = "7374.52" +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 = "ramamet4__nse-stocks-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ramamet4/nse-stocks-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7374.52" +QUESTION = "What is the average opening price of Nifty 50 across all recorded dates 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/0001_188_1188925_qa_3/instruction.md b/tasks/0001_188_1188925_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..31e37966a2af5a2699fd36ea44e7bc3072400060 --- /dev/null +++ b/tasks/0001_188_1188925_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): +- UCI_Credit_Card.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 credit card defaults? + +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_188_1188925_qa_3/task.toml b/tasks/0001_188_1188925_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..569a3cdea8114b21d446750f38e04a32acb7d9fc --- /dev/null +++ b/tasks/0001_188_1188925_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_188_1188925_qa_3" +description = "What percentage of the dataset consists of credit card defaults?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/188/1188925.ipynb_qa_3" +kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset" +gold_answer = "22" +reward_mode_initial = "numeric" +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__default-of-credit-card-clients-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "22" +QUESTION = "What percentage of the dataset consists of credit card defaults?" +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_189_1189227_qa_2/instruction.md b/tasks/0001_189_1189227_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a74a24e72e5c6c656d5ead5daa58869c8701f062 --- /dev/null +++ b/tasks/0001_189_1189227_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): +- UCI_Credit_Card.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean age of credit card holders who defaulted? + +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_189_1189227_qa_2/task.toml b/tasks/0001_189_1189227_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b452c73d3d2291fae2c7ed81fc6a6862f3cc8880 --- /dev/null +++ b/tasks/0001_189_1189227_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_189_1189227_qa_2" +description = "What is the mean age of credit card holders who defaulted?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/189/1189227.ipynb_qa_2" +kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset" +gold_answer = "35.73" +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__default-of-credit-card-clients-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "35.73" +QUESTION = "What is the mean age of credit card holders who defaulted?" +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_189_1189227_qa_5/instruction.md b/tasks/0001_189_1189227_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..038d40f2f149003e8d551e0467aadbaafcd5475c --- /dev/null +++ b/tasks/0001_189_1189227_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): +- UCI_Credit_Card.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many samples were allocated to the training 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/0001_189_1189227_qa_5/task.toml b/tasks/0001_189_1189227_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bf8fe56386854049f17e79fdf9b87a10347355fc --- /dev/null +++ b/tasks/0001_189_1189227_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_189_1189227_qa_5" +description = "How many samples were allocated to the training set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/189/1189227.ipynb_qa_5" +kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset" +gold_answer = "24000" +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__default-of-credit-card-clients-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "24000" +QUESTION = "How many samples were allocated to the training set?" +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_191_1191057_qa_4/instruction.md b/tasks/0001_191_1191057_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..697ae79860236e09f34cc010bbcb44ab8fde2610 --- /dev/null +++ b/tasks/0001_191_1191057_qa_4/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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which original features were removed from the dataset because they contained only a single unique value across all observations? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact column names. + +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_191_1191057_qa_4/task.toml b/tasks/0001_191_1191057_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0e8f4d0fa1369d2f0936b0154358351a1893d4df --- /dev/null +++ b/tasks/0001_191_1191057_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_191_1191057_qa_4" +description = "Which original features were removed from the dataset because they contained only a single unique value across all observations?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/191/1191057.ipynb_qa_4" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "EmployeeCount, Over18, StandardHours" +reward_mode_initial = "list" +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 = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "EmployeeCount, Over18, StandardHours" +QUESTION = "Which original features were removed from the dataset because they contained only a single unique value across all observations?" +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/0001_196_1196803_qa_3/instruction.md b/tasks/0001_196_1196803_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0697c034decc544459ea7e2c5eef8d2bb0c36551 --- /dev/null +++ b/tasks/0001_196_1196803_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): +- directory.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common ownership type among all Starbucks stores 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_196_1196803_qa_3/task.toml b/tasks/0001_196_1196803_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3e3f9e62bf59667a10ec6fb43854447313603209 --- /dev/null +++ b/tasks/0001_196_1196803_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_196_1196803_qa_3" +description = "What is the most common ownership type among all Starbucks stores in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/196/1196803.ipynb_qa_3" +kaggle_dataset_name = "starbucks/store-locations" +gold_answer = "Company Owned" +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 = "starbucks__store-locations" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "starbucks/store-locations" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Company Owned" +QUESTION = "What is the most common ownership type among all Starbucks stores 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_238_1238370_qa_1/instruction.md b/tasks/0001_238_1238370_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7490ce08ac1524270f57e2ae2ac3a55bd052801d --- /dev/null +++ b/tasks/0001_238_1238370_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): +- Netflix Shows.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique Netflix shows are present in the dataset, considering duplicate titles? + +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_238_1238370_qa_1/task.toml b/tasks/0001_238_1238370_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cbcc1e276e3a043ee25634af35a27dcd3c82dd21 --- /dev/null +++ b/tasks/0001_238_1238370_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_238_1238370_qa_1" +description = "How many unique Netflix shows are present in the dataset, considering duplicate titles?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/238/1238370.ipynb_qa_1" +kaggle_dataset_name = "chasewillden/netflix-shows" +gold_answer = "496" +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 = "chasewillden__netflix-shows" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "chasewillden/netflix-shows" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "496" +QUESTION = "How many unique Netflix shows are present in the dataset, considering duplicate titles?" +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_239_1239559_qa_4/instruction.md b/tasks/0001_239_1239559_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..72429ab479a2440a755ec3a1c43014ed9e48ad76 --- /dev/null +++ b/tasks/0001_239_1239559_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): +- chopstick-effectiveness.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How much does the average food pinching efficiency decrease from the optimal length (240mm) to the next length tested (270mm)? + +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_239_1239559_qa_4/task.toml b/tasks/0001_239_1239559_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..98c8450f06658933e914823ae3e258cd346d4e8a --- /dev/null +++ b/tasks/0001_239_1239559_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_239_1239559_qa_4" +description = "How much does the average food pinching efficiency decrease from the optimal length (240mm) to the next length tested (270mm)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/239/1239559.ipynb_qa_4" +kaggle_dataset_name = "priya2908/chopsticks-1992" +gold_answer = "1.999" +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 = "priya2908__chopsticks-1992" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "priya2908/chopsticks-1992" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.999" +QUESTION = "How much does the average food pinching efficiency decrease from the optimal length (240mm) to the next length tested (270mm)?" +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/0001_243_1243037_qa_2/instruction.md b/tasks/0001_243_1243037_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..503de46015f1ea0ed3daf778fe3480c626666021 --- /dev/null +++ b/tasks/0001_243_1243037_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: +Which feature exhibits the strongest positive correlation with the Outcome variable (diabetes status)? + +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_243_1243037_qa_2/task.toml b/tasks/0001_243_1243037_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4a119378b7bf7e60e9b355324fd76ff89977f92b --- /dev/null +++ b/tasks/0001_243_1243037_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_243_1243037_qa_2" +description = "Which feature exhibits the strongest positive correlation with the Outcome variable (diabetes status)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/243/1243037.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +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__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 = "Which feature exhibits the strongest positive correlation with the Outcome variable (diabetes status)?" +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_293_1293142_qa_5/instruction.md b/tasks/0001_293_1293142_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1d6c9dd6e631e446f6b1fc2569522b6b7654ceba --- /dev/null +++ b/tasks/0001_293_1293142_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): +- 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 correlation coefficient between the sqft_living feature and the log-transformed price variable 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_293_1293142_qa_5/task.toml b/tasks/0001_293_1293142_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ba39b503963c2090689e661e6bbdf1afa9c93e3c --- /dev/null +++ b/tasks/0001_293_1293142_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_293_1293142_qa_5" +description = "What is the correlation coefficient between the sqft_living feature and the log-transformed price variable in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/293/1293142.ipynb_qa_5" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "0.70" +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 = "0.70" +QUESTION = "What is the correlation coefficient between the sqft_living feature and the log-transformed price variable 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/0001_349_1349978_qa_4/instruction.md b/tasks/0001_349_1349978_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4673735d5e32824519ae43728357cdd45ec3aecb --- /dev/null +++ b/tasks/0001_349_1349978_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: +How many categorical features were originally present in the mushroom dataset before numerical encoding? + +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_349_1349978_qa_4/task.toml b/tasks/0001_349_1349978_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ca9433d7e143905aacf4a8d104cc3865ab6d6d98 --- /dev/null +++ b/tasks/0001_349_1349978_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_349_1349978_qa_4" +description = "How many categorical features were originally present in the mushroom dataset before numerical encoding?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/349/1349978.ipynb_qa_4" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "23" +reward_mode_initial = "numeric" +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 = "23" +QUESTION = "How many categorical features were originally present in the mushroom dataset before numerical encoding?" +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_353_1353632_qa_3/instruction.md b/tasks/0001_353_1353632_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5d7ba4b3b0ae4d005c62eceaf21eaf330b729833 --- /dev/null +++ b/tasks/0001_353_1353632_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): +- dataset.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference between the number of "run" samples collected on the left wrist versus "walk" samples on the same wrist? + +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_353_1353632_qa_3/task.toml b/tasks/0001_353_1353632_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6bfb9f4d77c0834247a14c5beb4a7c9bae6c849a --- /dev/null +++ b/tasks/0001_353_1353632_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_353_1353632_qa_3" +description = "What is the difference between the number of \"run\" samples collected on the left wrist versus \"walk\" samples on the same wrist?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/353/1353632.ipynb_qa_3" +kaggle_dataset_name = "vmalyi/run-or-walk" +gold_answer = "5086" +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 = "vmalyi__run-or-walk" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vmalyi/run-or-walk" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5086" +QUESTION = "What is the difference between the number of \"run\" samples collected on the left wrist versus \"walk\" samples on the same wrist?" +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_367_1367483_qa_4/instruction.md b/tasks/0001_367_1367483_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ff119179cecc7021eafe689ba1944038481cef76 --- /dev/null +++ b/tasks/0001_367_1367483_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): +- battles.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Did any attacker king achieve a 100% win rate in all battles fought 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_367_1367483_qa_4/task.toml b/tasks/0001_367_1367483_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..27aba6774869dcdb66ee20f12f48129e1b866780 --- /dev/null +++ b/tasks/0001_367_1367483_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_367_1367483_qa_4" +description = "Did any attacker king achieve a 100% win rate in all battles fought according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/367/1367483.ipynb_qa_4" +kaggle_dataset_name = "mylesoneill/game-of-thrones" +gold_answer = "Balon/Euron Greyjoy" +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 = "mylesoneill__game-of-thrones" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mylesoneill/game-of-thrones" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Balon/Euron Greyjoy" +QUESTION = "Did any attacker king achieve a 100% win rate in all battles fought according to 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_487_1487950_qa_3/instruction.md b/tasks/0001_487_1487950_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..305cef4b2c2f2c00b9daec3c6c31adf97e717a95 --- /dev/null +++ b/tasks/0001_487_1487950_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): +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total net investment required for betting $10 on every match 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_487_1487950_qa_3/task.toml b/tasks/0001_487_1487950_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9c587f364693a851c7974d8b3294b9319b42592c --- /dev/null +++ b/tasks/0001_487_1487950_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_487_1487950_qa_3" +description = "What is the total net investment required for betting $10 on every match in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/487/1487950.ipynb_qa_3" +kaggle_dataset_name = "hugomathien/soccer" +gold_answer = "259790" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "hugomathien__soccer" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hugomathien/soccer" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "259790" +QUESTION = "What is the total net investment required for betting $10 on every match 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_521_1521206_qa_2/instruction.md b/tasks/0001_521_1521206_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..37a846ed71b3e5ed04bb0f8862f679e7b5a4ef31 --- /dev/null +++ b/tasks/0001_521_1521206_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): +- titanic_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct Pclass values are present 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_521_1521206_qa_2/task.toml b/tasks/0001_521_1521206_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..095ef436dd77ad3969931cf82ea17572533da028 --- /dev/null +++ b/tasks/0001_521_1521206_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_521_1521206_qa_2" +description = "How many distinct Pclass values are present in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/521/1521206.ipynb_qa_2" +kaggle_dataset_name = "prkukunoor/TitanicDataset" +gold_answer = "3" +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 = "prkukunoor__TitanicDataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "prkukunoor/TitanicDataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many distinct Pclass values are present 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_527_1527039_qa_3/instruction.md b/tasks/0001_527_1527039_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..922fd4cacfc42b85340506863a5db1be9f704c66 --- /dev/null +++ b/tasks/0001_527_1527039_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): +- tarantino.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which specific expletive appears most frequently in Tarantino's films 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_527_1527039_qa_3/task.toml b/tasks/0001_527_1527039_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..adcc0f3c34e8db07c4d5a1088fb87b2ab6985529 --- /dev/null +++ b/tasks/0001_527_1527039_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_527_1527039_qa_3" +description = "Which specific expletive appears most frequently in Tarantino's films according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/527/1527039.ipynb_qa_3" +kaggle_dataset_name = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" +gold_answer = "fucking" +reward_mode_initial = "exact_short" +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 = "fivethirtyeight__cuss-words-and-deaths-in-quentin-tarantino-films" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "fucking" +QUESTION = "Which specific expletive appears most frequently in Tarantino's films according to 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_532_1532154_qa_5/instruction.md b/tasks/0001_532_1532154_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..41cc9aa8df0c8fecf5d7b014a7d9243606aac3e2 --- /dev/null +++ b/tasks/0001_532_1532154_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): +- indian_liver_patient.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average age of all patients 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_532_1532154_qa_5/task.toml b/tasks/0001_532_1532154_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3f28473fd0e10f08ed40c87ec339214da049396d --- /dev/null +++ b/tasks/0001_532_1532154_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_532_1532154_qa_5" +description = "What is the average age of all patients in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/532/1532154.ipynb_qa_5" +kaggle_dataset_name = "uciml/indian-liver-patient-records" +gold_answer = "44.746141" +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__indian-liver-patient-records" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/indian-liver-patient-records" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "44.746141" +QUESTION = "What is the average age of all patients 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/0001_538_1538781_qa_4/instruction.md b/tasks/0001_538_1538781_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..48f6c4c41aedd66358fe6d2432e4a341052f0fc6 --- /dev/null +++ b/tasks/0001_538_1538781_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): +- Suicides in India 2001-2012.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which professional category has the highest number of female suicides 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_538_1538781_qa_4/task.toml b/tasks/0001_538_1538781_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8497d489fb07605f21fd33399c096ed8be915b62 --- /dev/null +++ b/tasks/0001_538_1538781_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_538_1538781_qa_4" +description = "Which professional category has the highest number of female suicides according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/538/1538781.ipynb_qa_4" +kaggle_dataset_name = "rajanand/suicides-in-india" +gold_answer = "House Wife" +reward_mode_initial = "exact_short" +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 = "rajanand__suicides-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/suicides-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "House Wife" +QUESTION = "Which professional category has the highest number of female suicides according to 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_541_1541002_qa_4/instruction.md b/tasks/0001_541_1541002_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2a7e7c9b6f752d49b2482552402d0b7c5e23ab87 --- /dev/null +++ b/tasks/0001_541_1541002_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +In the stacked bar plot comparing platform sales by genre, which platform has the highest sales in the Sports category? + +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_541_1541002_qa_4/task.toml b/tasks/0001_541_1541002_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..db90cdfc47752985d02ffd163ae0c5767592fbf3 --- /dev/null +++ b/tasks/0001_541_1541002_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_541_1541002_qa_4" +description = "In the stacked bar plot comparing platform sales by genre, which platform has the highest sales in the Sports category?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/541/1541002.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Wii" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Wii" +QUESTION = "In the stacked bar plot comparing platform sales by genre, which platform has the highest sales in the Sports category?" +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_580_1580621_qa_4/instruction.md b/tasks/0001_580_1580621_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cf4cc576097b94e55fa46611a27c309e2e384828 --- /dev/null +++ b/tasks/0001_580_1580621_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median petal width in the entire 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_580_1580621_qa_4/task.toml b/tasks/0001_580_1580621_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c1b008d2d7aa05603bdfd748c38a5b44222d8cde --- /dev/null +++ b/tasks/0001_580_1580621_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_580_1580621_qa_4" +description = "What is the median petal width in the entire dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/580/1580621.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "1.3" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.3" +QUESTION = "What is the median petal width in the entire 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/0001_583_1583897_qa_3/instruction.md b/tasks/0001_583_1583897_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..17eb62efd9cccf733e458e312edc89157832b12f --- /dev/null +++ b/tasks/0001_583_1583897_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): +- xAPI-Edu-Data.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 students in the medium performance category (M) according to the Class distribution derived from the crosstab? + +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_583_1583897_qa_3/task.toml b/tasks/0001_583_1583897_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..63f600d0e5bf04c66efbfae1fbfa55f8e15a731b --- /dev/null +++ b/tasks/0001_583_1583897_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_583_1583897_qa_3" +description = "What is the total number of students in the medium performance category (M) according to the Class distribution derived from the crosstab?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/583/1583897.ipynb_qa_3" +kaggle_dataset_name = "aljarah/xAPI-Edu-Data" +gold_answer = "211" +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 = "aljarah__xAPI-Edu-Data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "aljarah/xAPI-Edu-Data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "211" +QUESTION = "What is the total number of students in the medium performance category (M) according to the Class distribution derived from the crosstab?" +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_623_1623388_qa_1/instruction.md b/tasks/0001_623_1623388_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..68bda898a09d483767c151a7734b706cebbb47d7 --- /dev/null +++ b/tasks/0001_623_1623388_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): +- utils.py + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique audio classes are represented in the collected samples? + +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_623_1623388_qa_1/task.toml b/tasks/0001_623_1623388_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..eed79e663e481a53617b02e16b5dc88b3385ab68 --- /dev/null +++ b/tasks/0001_623_1623388_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_623_1623388_qa_1" +description = "How many unique audio classes are represented in the collected samples?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/623/1623388.ipynb_qa_1" +kaggle_dataset_name = "mmoreaux/environmental-sound-classification-50" +gold_answer = "50" +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 = "mmoreaux__environmental-sound-classification-50" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mmoreaux/environmental-sound-classification-50" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "50" +QUESTION = "How many unique audio classes are represented in the collected samples?" +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_637_1637985_qa_3/instruction.md b/tasks/0001_637_1637985_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b3fe261416d7d56cd3fde69be86761a8d14997e6 --- /dev/null +++ b/tasks/0001_637_1637985_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): +- Mass Shootings Dataset.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 total victims per attack for perpetrators with mental health issues compared to those without? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, plain numbers). + +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_637_1637985_qa_3/task.toml b/tasks/0001_637_1637985_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6e7a91db595965b884d9919756af6ddfdcd2dc01 --- /dev/null +++ b/tasks/0001_637_1637985_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_637_1637985_qa_3" +description = "What is the average number of total victims per attack for perpetrators with mental health issues compared to those without?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/637/1637985.ipynb_qa_3" +kaggle_dataset_name = "zusmani/us-mass-shootings-last-50-years" +gold_answer = "12.3, 4.7" +reward_mode_initial = "list" +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 = "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 = "12.3, 4.7" +QUESTION = "What is the average number of total victims per attack for perpetrators with mental health issues compared to those without?" +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/0001_646_1646297_qa_2/instruction.md b/tasks/0001_646_1646297_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a43b704b1bf2a2a2dcd7b3d7896797bf80b22b43 --- /dev/null +++ b/tasks/0001_646_1646297_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): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset has the highest number of unique categories, and how many are there? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, feature name first, count as a plain number). + +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_646_1646297_qa_2/task.toml b/tasks/0001_646_1646297_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f18d68f183ffe871a24fb7796cb6051a56ebd323 --- /dev/null +++ b/tasks/0001_646_1646297_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_646_1646297_qa_2" +description = "Which feature in the dataset has the highest number of unique categories, and how many are there?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/646/1646297.ipynb_qa_2" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "gill-color, 12" +reward_mode_initial = "list" +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__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "gill-color, 12" +QUESTION = "Which feature in the dataset has the highest number of unique categories, and how many are there?" +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/0001_666_1666101_qa_5/instruction.md b/tasks/0001_666_1666101_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fc572780f11496e5561ab3f68c696f45b4e5a459 --- /dev/null +++ b/tasks/0001_666_1666101_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): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average cereal rating for manufacturer K? + +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_666_1666101_qa_5/task.toml b/tasks/0001_666_1666101_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fec060f835f34772075e47cd8ca5c708d3fd868a --- /dev/null +++ b/tasks/0001_666_1666101_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_666_1666101_qa_5" +description = "What is the average cereal rating for manufacturer K?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/666/1666101.ipynb_qa_5" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "44.04" +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 = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "44.04" +QUESTION = "What is the average cereal rating for manufacturer K?" +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_690_1690621_qa_2/instruction.md b/tasks/0001_690_1690621_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5b04872ee9de3401e40948ab97accc1d63296604 --- /dev/null +++ b/tasks/0001_690_1690621_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): +- salaries-by-college-type.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which college type has the highest median salary growth from starting to mid-career (Mid_50th percentile) based on 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_690_1690621_qa_2/task.toml b/tasks/0001_690_1690621_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bb5a92de00e52f5ea7c2dc448cf90d7ab5bb2d06 --- /dev/null +++ b/tasks/0001_690_1690621_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_690_1690621_qa_2" +description = "Which college type has the highest median salary growth from starting to mid-career (Mid_50th percentile) based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/690/1690621.ipynb_qa_2" +kaggle_dataset_name = "wsj/college-salaries" +gold_answer = "Ivy League" +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 = "wsj__college-salaries" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wsj/college-salaries" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Ivy League" +QUESTION = "Which college type has the highest median salary growth from starting to mid-career (Mid_50th percentile) based on 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_692_1692435_qa_5/instruction.md b/tasks/0001_692_1692435_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7b023a141ce9294892124968f03a03f88b5b5bb5 --- /dev/null +++ b/tasks/0001_692_1692435_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which species exhibits the largest average sepal length 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_692_1692435_qa_5/task.toml b/tasks/0001_692_1692435_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..97513ce6bfd66d9abd58fece4913ed7478a1ba3a --- /dev/null +++ b/tasks/0001_692_1692435_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_692_1692435_qa_5" +description = "Which species exhibits the largest average sepal length in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/692/1692435.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-virginica" +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 = "Iris-virginica" +QUESTION = "Which species exhibits the largest average sepal length 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_739_1739101_qa_3/instruction.md b/tasks/0001_739_1739101_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b0e25eaf5d9411f802288558281ac63384e591ca --- /dev/null +++ b/tasks/0001_739_1739101_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): +- multipleChoiceResponses.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median percentage of time spent on model building 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_739_1739101_qa_3/task.toml b/tasks/0001_739_1739101_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d3a89eb3ccd6f4b7bfefc1fe52f61a5dc1a453c5 --- /dev/null +++ b/tasks/0001_739_1739101_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_739_1739101_qa_3" +description = "What is the median percentage of time spent on model building according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/739/1739101.ipynb_qa_3" +kaggle_dataset_name = "kaggle/kaggle-survey-2017" +gold_answer = "20.00" +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 = "kaggle__kaggle-survey-2017" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kaggle/kaggle-survey-2017" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "20.00" +QUESTION = "What is the median percentage of time spent on model building according to 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/0001_825_1825877_qa_3/instruction.md b/tasks/0001_825_1825877_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..63e7932796aa58523413a925a6570d777a8c10a1 --- /dev/null +++ b/tasks/0001_825_1825877_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 year of operation for all patients 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_825_1825877_qa_3/task.toml b/tasks/0001_825_1825877_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b2d0dc17ebc90ac610c0bd6ccb053c6d04fd33f6 --- /dev/null +++ b/tasks/0001_825_1825877_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_825_1825877_qa_3" +description = "What is the standard deviation of the year of operation for all patients in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/825/1825877.ipynb_qa_3" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "3.249405" +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 = "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 = "3.249405" +QUESTION = "What is the standard deviation of the year of operation for all patients 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/0001_871_1871102_qa_2/instruction.md b/tasks/0001_871_1871102_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fb0246542408e4eb96eef29a0cd44dba06cf63d7 --- /dev/null +++ b/tasks/0001_871_1871102_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): +- output3.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique classes are present in the categorical labels after conversion to categorical format? + +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_871_1871102_qa_2/task.toml b/tasks/0001_871_1871102_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2907db403a54c7af1210ddf33a20084a79f5ff35 --- /dev/null +++ b/tasks/0001_871_1871102_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_871_1871102_qa_2" +description = "How many unique classes are present in the categorical labels after conversion to categorical format?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/871/1871102.ipynb_qa_2" +kaggle_dataset_name = "richardbj/2chan10dbnoise" +gold_answer = "3" +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 = "richardbj__2chan10dbnoise" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "richardbj/2chan10dbnoise" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many unique classes are present in the categorical labels after conversion to categorical format?" +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_876_1876377_qa_2/instruction.md b/tasks/0001_876_1876377_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..52780d354a2a200307963d9659d468093137df9f --- /dev/null +++ b/tasks/0001_876_1876377_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): +- UCI_Credit_Card.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which gender category has the highest default payment probability, and what is its value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, percentage with two decimals). + +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_876_1876377_qa_2/task.toml b/tasks/0001_876_1876377_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7cc38fd4c17519704ce1b948876c51009e6d84ab --- /dev/null +++ b/tasks/0001_876_1876377_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_876_1876377_qa_2" +description = "Which gender category has the highest default payment probability, and what is its value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/876/1876377.ipynb_qa_2" +kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset" +gold_answer = "Male, 24.17%" +reward_mode_initial = "list" +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__default-of-credit-card-clients-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Male, 24.17%" +QUESTION = "Which gender category has the highest default payment probability, and what is its value?" +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_885_1885477_qa_5/instruction.md b/tasks/0001_885_1885477_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9ace6ae318ed88df8e90ff5488951350f946c1ee --- /dev/null +++ b/tasks/0001_885_1885477_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): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average vitamin content in cereals rated 50 or below? + +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_885_1885477_qa_5/task.toml b/tasks/0001_885_1885477_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5d4c78727e7d4f42a1fe22ab1c115158a4459188 --- /dev/null +++ b/tasks/0001_885_1885477_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_885_1885477_qa_5" +description = "What is the average vitamin content in cereals rated 50 or below?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/885/1885477.ipynb_qa_5" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "32.589285714285715" +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 = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "32.589285714285715" +QUESTION = "What is the average vitamin content in cereals rated 50 or below?" +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/0001_888_1888068_qa_2/instruction.md b/tasks/0001_888_1888068_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1f26ff73ebbb25ccc2ae8eb91e98a3979ec92050 --- /dev/null +++ b/tasks/0001_888_1888068_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): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What are the mean sodium contents (in mg) for hot and cold cereals respectively? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, in that order, keep two decimals). + +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_888_1888068_qa_2/task.toml b/tasks/0001_888_1888068_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1dc55d50862c780b60d463b5f878c3a3914a8e73 --- /dev/null +++ b/tasks/0001_888_1888068_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_888_1888068_qa_2" +description = "What are the mean sodium contents (in mg) for hot and cold cereals respectively?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/888/1888068.ipynb_qa_2" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "26.67, 165.07" +reward_mode_initial = "list" +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 = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "26.67, 165.07" +QUESTION = "What are the mean sodium contents (in mg) for hot and cold cereals respectively?" +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/0001_904_1904660_qa_4/instruction.md b/tasks/0001_904_1904660_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..da4c2bc1e9485b7ee2671a24c37ad5cbb49b2948 --- /dev/null +++ b/tasks/0001_904_1904660_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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct wine quality scores are present 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_904_1904660_qa_4/task.toml b/tasks/0001_904_1904660_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..deedf788ff4589f7dd9d9e3c829577d5ab60c349 --- /dev/null +++ b/tasks/0001_904_1904660_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_904_1904660_qa_4" +description = "How many distinct wine quality scores are present in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/904/1904660.ipynb_qa_4" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "6" +reward_mode_initial = "numeric" +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__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 = "How many distinct wine quality scores are present 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_991_1991376_qa_4/instruction.md b/tasks/0001_991_1991376_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6d9d78d124621c821c93895199c3e8aae63a4e4c --- /dev/null +++ b/tasks/0001_991_1991376_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): +- Credit.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of individuals in the dataset maintain a credit card balance greater than zero? + +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_991_1991376_qa_4/task.toml b/tasks/0001_991_1991376_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e4f0ff3e44c61be540dec475b264038ca1b9a959 --- /dev/null +++ b/tasks/0001_991_1991376_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_991_1991376_qa_4" +description = "What percentage of individuals in the dataset maintain a credit card balance greater than zero?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/991/1991376.ipynb_qa_4" +kaggle_dataset_name = "ishaanv/ISLR-Auto" +gold_answer = "77.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 = "ishaanv__ISLR-Auto" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ishaanv/ISLR-Auto" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "77.5" +QUESTION = "What percentage of individuals in the dataset maintain a credit card balance greater than zero?" +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/0002_094_2094789_qa_1/instruction.md b/tasks/0002_094_2094789_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f09421dbdb59cf34ff28639ac1922083ed4f2bb6 --- /dev/null +++ b/tasks/0002_094_2094789_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): +- 2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which variable has the highest positive correlation with the Happiness Score according to the 2017 dataset 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/0002_094_2094789_qa_1/task.toml b/tasks/0002_094_2094789_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..78571a3a7991fbf67b094601462f9fb78415c457 --- /dev/null +++ b/tasks/0002_094_2094789_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0002_094_2094789_qa_1" +description = "Which variable has the highest positive correlation with the Happiness Score according to the 2017 dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/094/2094789.ipynb_qa_1" +kaggle_dataset_name = "unsdsn/world-happiness" +gold_answer = "Economy (GDP per Capita)" +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 = "unsdsn__world-happiness" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "unsdsn/world-happiness" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Economy (GDP per Capita)" +QUESTION = "Which variable has the highest positive correlation with the Happiness Score according to the 2017 dataset analysis?" +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/0002_094_2094844_qa_1/instruction.md b/tasks/0002_094_2094844_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e01b0412c674ce8c417e82a1392e1c9fa5dd0e5a --- /dev/null +++ b/tasks/0002_094_2094844_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): +- tweets.xlsx + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which organization achieved the highest total retweets across all tweets 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/0002_094_2094844_qa_1/task.toml b/tasks/0002_094_2094844_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..75171bfc74ae93e0bfdb656a2db5f8dae5a7871d --- /dev/null +++ b/tasks/0002_094_2094844_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0002_094_2094844_qa_1" +description = "Which organization achieved the highest total retweets across all tweets in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/094/2094844.ipynb_qa_1" +kaggle_dataset_name = "derrickmwiti/24-thousand-tweets-later" +gold_answer = "ActiveSpaces" +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 = "derrickmwiti__24-thousand-tweets-later" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "derrickmwiti/24-thousand-tweets-later" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "ActiveSpaces" +QUESTION = "Which organization achieved the highest total retweets across all tweets 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/0002_156_2156667_qa_2/instruction.md b/tasks/0002_156_2156667_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d5d0a6f75683c4eecffe39b2e6c16e87ec76b2f8 --- /dev/null +++ b/tasks/0002_156_2156667_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): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Pokemon type (Type 2) has the highest median Defense stat in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact type names, in the order given. + +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/0002_156_2156667_qa_2/task.toml b/tasks/0002_156_2156667_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1171e584527122bd308af5bcff12e4391780c9a3 --- /dev/null +++ b/tasks/0002_156_2156667_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0002_156_2156667_qa_2" +description = "Which Pokemon type (Type 2) has the highest median Defense stat in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/156/2156667.ipynb_qa_2" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "Rock, Ground" +reward_mode_initial = "list" +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 = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Rock, Ground" +QUESTION = "Which Pokemon type (Type 2) has the highest median Defense stat in 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/0002_203_2203940_qa_5/instruction.md b/tasks/0002_203_2203940_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8eddbf9df60438bbd479bd24022874edb0ab3a3a --- /dev/null +++ b/tasks/0002_203_2203940_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of samples in the original wine dataset before any data splitting? + +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/0002_203_2203940_qa_5/task.toml b/tasks/0002_203_2203940_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a3c3365682ec5da3f1ccc09ab15058bcc988fb4b --- /dev/null +++ b/tasks/0002_203_2203940_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0002_203_2203940_qa_5" +description = "What is the total number of samples in the original wine dataset before any data splitting?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/203/2203940.ipynb_qa_5" +kaggle_dataset_name = "brynja/wineuci" +gold_answer = "178" +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 = "brynja__wineuci" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brynja/wineuci" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "178" +QUESTION = "What is the total number of samples in the original wine dataset before any data splitting?" +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/0002_219_2219893_qa_3/instruction.md b/tasks/0002_219_2219893_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..89e4158265c3b0286566da572a72ecd52aec8ec6 --- /dev/null +++ b/tasks/0002_219_2219893_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): +- winemag-data_first150k.csv +- 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 has the highest average wine rating (points) 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/0002_219_2219893_qa_3/task.toml b/tasks/0002_219_2219893_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fe7b96f49f61536cce843eed9ad9a16666bf0df3 --- /dev/null +++ b/tasks/0002_219_2219893_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0002_219_2219893_qa_3" +description = "Which country has the highest average wine rating (points) according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/219/2219893.ipynb_qa_3" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "England" +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 = "England" +QUESTION = "Which country has the highest average wine rating (points) according to 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/0002_240_2240465_qa_4/instruction.md b/tasks/0002_240_2240465_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ca34c7a946f054def4ad02ff23409fb70902f884 --- /dev/null +++ b/tasks/0002_240_2240465_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the 90th percentile of USD pledged amount for technology category projects? + +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/0002_240_2240465_qa_4/task.toml b/tasks/0002_240_2240465_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..81b74e5b6f1fb6fff6475ebfee37423a34150241 --- /dev/null +++ b/tasks/0002_240_2240465_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0002_240_2240465_qa_4" +description = "What is the 90th percentile of USD pledged amount for technology category projects?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/240/2240465.ipynb_qa_4" +kaggle_dataset_name = "kemical/kickstarter-projects" +gold_answer = "21223.50" +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 = "kemical__kickstarter-projects" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kemical/kickstarter-projects" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "21223.50" +QUESTION = "What is the 90th percentile of USD pledged amount for technology category projects?" +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_708_10708335_qa_2/instruction.md b/tasks/0010_708_10708335_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1a5f69ee918df8a8f798fc996f5d2d58df8affb7 --- /dev/null +++ b/tasks/0010_708_10708335_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): +- Authors.csv +- PaperAuthors.csv +- Papers.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 publications for authors who have contributed to multiple papers (i.e., authors with more than one publication)? + +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/0010_708_10708335_qa_2/task.toml b/tasks/0010_708_10708335_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c128338fa1637319591fa2f11623bb2d71282fef --- /dev/null +++ b/tasks/0010_708_10708335_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0010_708_10708335_qa_2" +description = "What is the average number of publications for authors who have contributed to multiple papers (i.e., authors with more than one publication)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0010/708/10708335.ipynb_qa_2" +kaggle_dataset_name = "benhamner/nips-2015-papers" +gold_answer = "2.388571428571429" +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 = "benhamner__nips-2015-papers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "benhamner/nips-2015-papers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2.388571428571429" +QUESTION = "What is the average number of publications for authors who have contributed to multiple papers (i.e., authors with more than one publication)?" +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/0011_587_11587305_qa_5/instruction.md b/tasks/0011_587_11587305_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f21f6aa21bf811d719c419d7c9e57c211f76178d --- /dev/null +++ b/tasks/0011_587_11587305_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): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of patients who did not survive had fewer than 10 positive lymph nodes based on the CDF 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/0011_587_11587305_qa_5/task.toml b/tasks/0011_587_11587305_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b360cabd9fad2882398fa9e0f329eaabe13a6ac3 --- /dev/null +++ b/tasks/0011_587_11587305_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0011_587_11587305_qa_5" +description = "What percentage of patients who did not survive had fewer than 10 positive lymph nodes based on the CDF analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/587/11587305.ipynb_qa_5" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "70" +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 = "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 = "70" +QUESTION = "What percentage of patients who did not survive had fewer than 10 positive lymph nodes based on the CDF analysis?" +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/0011_998_11998157_qa_3/instruction.md b/tasks/0011_998_11998157_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b82a1a0f82ae67df32057428f761346990899cc4 --- /dev/null +++ b/tasks/0011_998_11998157_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): +- ks-projects-201801.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average USD goal amount for all projects 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/0011_998_11998157_qa_3/task.toml b/tasks/0011_998_11998157_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c240cc394b0524be60b75705ab7655174240840f --- /dev/null +++ b/tasks/0011_998_11998157_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0011_998_11998157_qa_3" +description = "What is the average USD goal amount for all projects in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/998/11998157.ipynb_qa_3" +kaggle_dataset_name = "kemical/kickstarter-projects" +gold_answer = "45454.40" +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 = "kemical__kickstarter-projects" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kemical/kickstarter-projects" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "45454.40" +QUESTION = "What is the average USD goal amount for all projects 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/0011_998_11998157_qa_4/instruction.md b/tasks/0011_998_11998157_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6c689a19f6109061a64ecde4e774d353ee1b62a7 --- /dev/null +++ b/tasks/0011_998_11998157_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): +- ks-projects-201801.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent project state 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/0011_998_11998157_qa_4/task.toml b/tasks/0011_998_11998157_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b1ded89d379fd753b052ff581c541db3300090a1 --- /dev/null +++ b/tasks/0011_998_11998157_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0011_998_11998157_qa_4" +description = "What is the most frequent project state in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/998/11998157.ipynb_qa_4" +kaggle_dataset_name = "kemical/kickstarter-projects" +gold_answer = "failed" +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 = "kemical__kickstarter-projects" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kemical/kickstarter-projects" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "failed" +QUESTION = "What is the most frequent project state 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/0012_112_12112975_qa_3/instruction.md b/tasks/0012_112_12112975_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7419f7b217e827b43220879eb422b5f57c170232 --- /dev/null +++ b/tasks/0012_112_12112975_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): +- student-por.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the size of the training dataset after splitting 20% of the data for testing? + +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/0012_112_12112975_qa_3/task.toml b/tasks/0012_112_12112975_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3b87d6507034c463f4a67cf5347206c8820ba66b --- /dev/null +++ b/tasks/0012_112_12112975_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0012_112_12112975_qa_3" +description = "What is the size of the training dataset after splitting 20% of the data for testing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0012/112/12112975.ipynb_qa_3" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "519" +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__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "519" +QUESTION = "What is the size of the training dataset after splitting 20% of the data for testing?" +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/0012_161_12161282_qa_4/instruction.md b/tasks/0012_161_12161282_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b40d755d5cae1f185852e50bd7846e201ca90928 --- /dev/null +++ b/tasks/0012_161_12161282_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the dataset corresponds to diabetic outcomes (Outcome=1)? + +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/0012_161_12161282_qa_4/task.toml b/tasks/0012_161_12161282_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f37d57736c7cea64b9ad36f1fe913da02346e7d5 --- /dev/null +++ b/tasks/0012_161_12161282_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0012_161_12161282_qa_4" +description = "What percentage of the dataset corresponds to diabetic outcomes (Outcome=1)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0012/161/12161282.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "34.9" +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__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 = "34.9" +QUESTION = "What percentage of the dataset corresponds to diabetic outcomes (Outcome=1)?" +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/0013_081_13081725_qa_3/instruction.md b/tasks/0013_081_13081725_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7b3eddf4fe06ee0184d7547d31396b4482fd0d44 --- /dev/null +++ b/tasks/0013_081_13081725_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): +- GlobalLandTemperaturesByState.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many countries in the dataset have an average temperature above 15°C from 1970 to 2013? + +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/0013_081_13081725_qa_3/task.toml b/tasks/0013_081_13081725_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..223441005ca38ee28cdc42795e9ee68ce36f856d --- /dev/null +++ b/tasks/0013_081_13081725_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0013_081_13081725_qa_3" +description = "How many countries in the dataset have an average temperature above 15°C from 1970 to 2013?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/081/13081725.ipynb_qa_3" +kaggle_dataset_name = "berkeleyearth/climate-change-earth-surface-temperature-data" +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 = "berkeleyearth__climate-change-earth-surface-temperature-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "berkeleyearth/climate-change-earth-surface-temperature-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many countries in the dataset have an average temperature above 15°C from 1970 to 2013?" +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/0013_169_13169934_qa_5/instruction.md b/tasks/0013_169_13169934_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cabf53344541ddc52237275436a5f3b3002991f1 --- /dev/null +++ b/tasks/0013_169_13169934_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): +- games.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which team has a higher average number of inhibitor kills when they win the game 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/0013_169_13169934_qa_5/task.toml b/tasks/0013_169_13169934_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9becf6dcb87b3dabe0f31e26c871bc3dd84958c8 --- /dev/null +++ b/tasks/0013_169_13169934_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0013_169_13169934_qa_5" +description = "Which team has a higher average number of inhibitor kills when they win the game according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/169/13169934.ipynb_qa_5" +kaggle_dataset_name = "datasnaek/league-of-legends" +gold_answer = "Team 1" +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 = "datasnaek__league-of-legends" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datasnaek/league-of-legends" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Team 1" +QUESTION = "Which team has a higher average number of inhibitor kills when they win the game according to 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/0013_604_13604091_qa_2/instruction.md b/tasks/0013_604_13604091_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6738fa242906e07ca01269efe14e997ae8555910 --- /dev/null +++ b/tasks/0013_604_13604091_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): +- events.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What proportion of all user interactions in the dataset represent completed purchase transactions? + +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/0013_604_13604091_qa_2/task.toml b/tasks/0013_604_13604091_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..955ddbbf6fa3baf72af2ede71570ef76e774f8ca --- /dev/null +++ b/tasks/0013_604_13604091_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0013_604_13604091_qa_2" +description = "What proportion of all user interactions in the dataset represent completed purchase transactions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/604/13604091.ipynb_qa_2" +kaggle_dataset_name = "retailrocket/ecommerce-dataset" +gold_answer = "0.008148" +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 = "retailrocket__ecommerce-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "retailrocket/ecommerce-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.008148" +QUESTION = "What proportion of all user interactions in the dataset represent completed purchase transactions?" +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/0013_655_13655596_qa_1/instruction.md b/tasks/0013_655_13655596_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..37b08ee508670a4c2c1994244ac2229648575a0b --- /dev/null +++ b/tasks/0013_655_13655596_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): +- Tweets.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the predicted sentiment for the user input "Not happy with the flight, too boring and late"? + +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/0013_655_13655596_qa_1/task.toml b/tasks/0013_655_13655596_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c7b2f8db8b8bc5e151506d9d61cf00099a15a771 --- /dev/null +++ b/tasks/0013_655_13655596_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0013_655_13655596_qa_1" +description = "What is the predicted sentiment for the user input \"Not happy with the flight, too boring and late\"?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/655/13655596.ipynb_qa_1" +kaggle_dataset_name = "crowdflower/twitter-airline-sentiment" +gold_answer = "-1" +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 = "crowdflower__twitter-airline-sentiment" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crowdflower/twitter-airline-sentiment" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "-1" +QUESTION = "What is the predicted sentiment for the user input \"Not happy with the flight, too boring and late\"?" +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/0013_839_13839617_qa_5/instruction.md b/tasks/0013_839_13839617_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..460d65dc354fdc592b304f05e5a829c030d18d89 --- /dev/null +++ b/tasks/0013_839_13839617_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): +- indian_liver_patient.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median age of patients in the dataset after removing 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/0013_839_13839617_qa_5/task.toml b/tasks/0013_839_13839617_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..58a906e5eb6d2c25b0a8852159860e1956e00a49 --- /dev/null +++ b/tasks/0013_839_13839617_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0013_839_13839617_qa_5" +description = "What is the median age of patients in the dataset after removing missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/839/13839617.ipynb_qa_5" +kaggle_dataset_name = "uciml/indian-liver-patient-records" +gold_answer = "45" +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__indian-liver-patient-records" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/indian-liver-patient-records" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "45" +QUESTION = "What is the median age of patients in the dataset after removing missing values?" +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/0013_911_13911248_qa_1/instruction.md b/tasks/0013_911_13911248_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7b0e62dcfbc5b31fa7d7fcce301cdac4eab2617b --- /dev/null +++ b/tasks/0013_911_13911248_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 difference in mean values of positive_axillary_nodes between patients who did not survive (class "no") and those who survived (class "yes") after 5 years of treatment? + +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/0013_911_13911248_qa_1/task.toml b/tasks/0013_911_13911248_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..09a0ea7d7427c3db8cba7f18f96beec63cd4b455 --- /dev/null +++ b/tasks/0013_911_13911248_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0013_911_13911248_qa_1" +description = "What is the difference in mean values of positive_axillary_nodes between patients who did not survive (class \"no\") and those who survived (class \"yes\") after 5 years of treatment?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/911/13911248.ipynb_qa_1" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "4.6657" +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 = "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.6657" +QUESTION = "What is the difference in mean values of positive_axillary_nodes between patients who did not survive (class \"no\") and those who survived (class \"yes\") after 5 years of treatment?" +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/0014_124_14124969_qa_5/instruction.md b/tasks/0014_124_14124969_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5c65ff0033b5f3d413543d102d3f2ca19c5b426f --- /dev/null +++ b/tasks/0014_124_14124969_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): +- pima-indians-diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum 'Age' value among the detected outliers 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_124_14124969_qa_5/task.toml b/tasks/0014_124_14124969_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9157ab657aba0ddc0d3595fb35dbb8ef76d79b78 --- /dev/null +++ b/tasks/0014_124_14124969_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0014_124_14124969_qa_5" +description = "What is the maximum 'Age' value among the detected outliers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/124/14124969.ipynb_qa_5" +kaggle_dataset_name = "kumargh/pimaindiansdiabetescsv" +gold_answer = "81" +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 = "kumargh__pimaindiansdiabetescsv" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kumargh/pimaindiansdiabetescsv" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "81" +QUESTION = "What is the maximum 'Age' value among the detected outliers 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/0014_469_14469283_qa_3/instruction.md b/tasks/0014_469_14469283_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c4358cee01d1e3628f2eb36af1f07ab70875725b --- /dev/null +++ b/tasks/0014_469_14469283_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): +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the shape of the standardized training input features after data preprocessing? + +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_469_14469283_qa_3/task.toml b/tasks/0014_469_14469283_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d1a6f62efdb3f105fe34cd2459b5b512ff853681 --- /dev/null +++ b/tasks/0014_469_14469283_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0014_469_14469283_qa_3" +description = "What is the shape of the standardized training input features after data preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/469/14469283.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "(112, 4)" +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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "(112, 4)" +QUESTION = "What is the shape of the standardized training input features after data preprocessing?" +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/0014_469_14469283_qa_4/instruction.md b/tasks/0014_469_14469283_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fcf1092eca76bd808ccd2551432974989cf26df1 --- /dev/null +++ b/tasks/0014_469_14469283_qa_4/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): +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the distribution of the three iris species in the original dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of three numbers in the order: setosa, versicolor, virginica. + +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_469_14469283_qa_4/task.toml b/tasks/0014_469_14469283_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4da9ea0fb4c564722692c1262e6403cfdd41d782 --- /dev/null +++ b/tasks/0014_469_14469283_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0014_469_14469283_qa_4" +description = "What is the distribution of the three iris species in the original dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/469/14469283.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "50, 50, 50" +reward_mode_initial = "list" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "50, 50, 50" +QUESTION = "What is the distribution of the three iris species in the original dataset?" +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/0014_701_14701455_qa_3/instruction.md b/tasks/0014_701_14701455_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3615d66989b1826d1ee2a8006ddf3d7c3fe2021b --- /dev/null +++ b/tasks/0014_701_14701455_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: +What is the most frequently occurring stock code 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/0014_701_14701455_qa_3/task.toml b/tasks/0014_701_14701455_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..68c685dbcd6de5d20a951b947a606cae7d82cc28 --- /dev/null +++ b/tasks/0014_701_14701455_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0014_701_14701455_qa_3" +description = "What is the most frequently occurring stock code in the cleaned dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/701/14701455.ipynb_qa_3" +kaggle_dataset_name = "carrie1/ecommerce-data" +gold_answer = "85123A" +reward_mode_initial = "exact_short" +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 = "carrie1__ecommerce-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "carrie1/ecommerce-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "85123A" +QUESTION = "What is the most frequently occurring stock code in the cleaned 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/0014_933_14933483_qa_2/instruction.md b/tasks/0014_933_14933483_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..29fc6dd4f11d0235f7efaea044ea9cdbd37261d5 --- /dev/null +++ b/tasks/0014_933_14933483_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: +What is the minimum PetalWidthCm value recorded 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_933_14933483_qa_2/task.toml b/tasks/0014_933_14933483_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c5bbd25651725f3a227700f7a8571a24b8d8d864 --- /dev/null +++ b/tasks/0014_933_14933483_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0014_933_14933483_qa_2" +description = "What is the minimum PetalWidthCm value recorded in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/933/14933483.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.1" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.1" +QUESTION = "What is the minimum PetalWidthCm value recorded 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/0014_952_14952543_qa_1/instruction.md b/tasks/0014_952_14952543_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8958cd9522c988bff6b0011238bad1ddf3105452 --- /dev/null +++ b/tasks/0014_952_14952543_qa_1/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct price range categories are present in the mobile phone 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_952_14952543_qa_1/task.toml b/tasks/0014_952_14952543_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..26f6f35d28e9391962f8ef893c07571f5739e3c0 --- /dev/null +++ b/tasks/0014_952_14952543_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0014_952_14952543_qa_1" +description = "How many distinct price range categories are present in the mobile phone dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/952/14952543.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "4" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "How many distinct price range categories are present in the mobile phone 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/0016_135_16135360_qa_2/instruction.md b/tasks/0016_135_16135360_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..29c3bb3ccb9e7f44550ec14a5ddbd5514c7afc3f --- /dev/null +++ b/tasks/0016_135_16135360_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): +- cities_r2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which state ranks highest based on the composite parameter combining normalized graduate ratio, sex ratio, and literacy rate? + +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/0016_135_16135360_qa_2/task.toml b/tasks/0016_135_16135360_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..424d7abb706c9238f2a7a37684481488d4a07a07 --- /dev/null +++ b/tasks/0016_135_16135360_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0016_135_16135360_qa_2" +description = "Which state ranks highest based on the composite parameter combining normalized graduate ratio, sex ratio, and literacy rate?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/135/16135360.ipynb_qa_2" +kaggle_dataset_name = "zed9941/top-500-indian-cities" +gold_answer = "Manipur" +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 = "zed9941__top-500-indian-cities" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zed9941/top-500-indian-cities" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Manipur" +QUESTION = "Which state ranks highest based on the composite parameter combining normalized graduate ratio, sex ratio, and literacy rate?" +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/0016_558_16558367_qa_1/instruction.md b/tasks/0016_558_16558367_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a1c76f262a4871bc28d44ea6b8b8c785c47d681d --- /dev/null +++ b/tasks/0016_558_16558367_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 user has the highest total positive sentiment score 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/0016_558_16558367_qa_1/task.toml b/tasks/0016_558_16558367_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..433e142b3d40b632f2c1db90a2c69f8f93d72cad --- /dev/null +++ b/tasks/0016_558_16558367_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0016_558_16558367_qa_1" +description = "Which user has the highest total positive sentiment score according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/558/16558367.ipynb_qa_1" +kaggle_dataset_name = "arathee2/demonetization-in-india-twitter-data" +gold_answer = "mituamin" +reward_mode_initial = "exact_short" +package_tier = 0 +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 = "arathee2__demonetization-in-india-twitter-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arathee2/demonetization-in-india-twitter-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "mituamin" +QUESTION = "Which user has the highest total positive sentiment score according to 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/0016_712_16712977_qa_5/instruction.md b/tasks/0016_712_16712977_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0fe305fbd746ebcd0ea50a785f7ecc86f78f72ea --- /dev/null +++ b/tasks/0016_712_16712977_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): +- Tweets.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many negative sentiment tweets are attributed to "Late Flight" for US Airways? + +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/0016_712_16712977_qa_5/task.toml b/tasks/0016_712_16712977_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b17f47af8c7c7c0eea1abf170cbf0bc4061f935f --- /dev/null +++ b/tasks/0016_712_16712977_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0016_712_16712977_qa_5" +description = "How many negative sentiment tweets are attributed to \"Late Flight\" for US Airways?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/712/16712977.ipynb_qa_5" +kaggle_dataset_name = "crowdflower/twitter-airline-sentiment" +gold_answer = "453" +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 = "crowdflower__twitter-airline-sentiment" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crowdflower/twitter-airline-sentiment" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "453" +QUESTION = "How many negative sentiment tweets are attributed to \"Late Flight\" for US Airways?" +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/0017_247_17247673_qa_2/instruction.md b/tasks/0017_247_17247673_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c4382813e45f41270b66c2fc0de8126e7cb66b61 --- /dev/null +++ b/tasks/0017_247_17247673_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): +- 2017.csv +- 2016.csv +- 2015.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many countries in 2017 had a Family score below 0.5? + +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/0017_247_17247673_qa_2/task.toml b/tasks/0017_247_17247673_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..35911210df910c1355b193781798def7becf54d9 --- /dev/null +++ b/tasks/0017_247_17247673_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0017_247_17247673_qa_2" +description = "How many countries in 2017 had a Family score below 0.5?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/247/17247673.ipynb_qa_2" +kaggle_dataset_name = "unsdsn/world-happiness" +gold_answer = "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 = "unsdsn__world-happiness" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "unsdsn/world-happiness" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "How many countries in 2017 had a Family score below 0.5?" +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/0017_311_17311492_qa_2/instruction.md b/tasks/0017_311_17311492_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..55c37b6c3c1d3cb1c4c48d5a9d8d4529ed21da5b --- /dev/null +++ b/tasks/0017_311_17311492_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): +- 2015.csv +- 2016.csv +- 2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which year had the highest maximum happiness score across the 2015–2017 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/0017_311_17311492_qa_2/task.toml b/tasks/0017_311_17311492_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7b30aa247899969a417680f8ad057f605db780a2 --- /dev/null +++ b/tasks/0017_311_17311492_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0017_311_17311492_qa_2" +description = "Which year had the highest maximum happiness score across the 2015–2017 dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/311/17311492.ipynb_qa_2" +kaggle_dataset_name = "unsdsn/world-happiness" +gold_answer = "2015" +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 = "unsdsn__world-happiness" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "unsdsn/world-happiness" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2015" +QUESTION = "Which year had the highest maximum happiness score across the 2015–2017 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/0017_565_17565404_qa_2/instruction.md b/tasks/0017_565_17565404_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fd9816147682ef922e661e8f7d05e9f558df135c --- /dev/null +++ b/tasks/0017_565_17565404_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): +- HR_comma_sep.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which department has the highest average employee satisfaction level? + +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/0017_565_17565404_qa_2/task.toml b/tasks/0017_565_17565404_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0edfd5b6e852b15029ef155fbc001d72f09c4e8d --- /dev/null +++ b/tasks/0017_565_17565404_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0017_565_17565404_qa_2" +description = "Which department has the highest average employee satisfaction level?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/565/17565404.ipynb_qa_2" +kaggle_dataset_name = "arvindbhatt/hrcsv" +gold_answer = "management" +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 = "arvindbhatt__hrcsv" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arvindbhatt/hrcsv" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "management" +QUESTION = "Which department has the highest average employee satisfaction level?" +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/0017_795_17795348_qa_5/instruction.md b/tasks/0017_795_17795348_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8fb651e999cd67340a35ad4c13ae017378ba5624 --- /dev/null +++ b/tasks/0017_795_17795348_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): +- matches.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which team won the most tosses across all seasons 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/0017_795_17795348_qa_5/task.toml b/tasks/0017_795_17795348_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c01a2cc90308c92476c2ea53921539e7e197507c --- /dev/null +++ b/tasks/0017_795_17795348_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0017_795_17795348_qa_5" +description = "Which team won the most tosses across all seasons in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/795/17795348.ipynb_qa_5" +kaggle_dataset_name = "manasgarg/ipl" +gold_answer = "Mumbai Indians" +reward_mode_initial = "exact_short" +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 = "manasgarg__ipl" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "manasgarg/ipl" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Mumbai Indians" +QUESTION = "Which team won the most tosses across all seasons 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/0017_920_17920359_qa_1/instruction.md b/tasks/0017_920_17920359_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a55f352490bf8f746ada39822535ac19a43513f1 --- /dev/null +++ b/tasks/0017_920_17920359_qa_1/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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which video game genre has the highest number of published games, and what is the total count? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, genre first, count as a plain number). + +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/0017_920_17920359_qa_1/task.toml b/tasks/0017_920_17920359_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..89b441824564c471f4c2e69d4b148a9054b527d5 --- /dev/null +++ b/tasks/0017_920_17920359_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0017_920_17920359_qa_1" +description = "Which video game genre has the highest number of published games, and what is the total count?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/920/17920359.ipynb_qa_1" +kaggle_dataset_name = "kedokedokedo/vgsales" +gold_answer = "Action, 3252" +reward_mode_initial = "list" +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 = "kedokedokedo__vgsales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kedokedokedo/vgsales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Action, 3252" +QUESTION = "Which video game genre has the highest number of published games, and what is the total count?" +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/0018_038_18038519_qa_5/instruction.md b/tasks/0018_038_18038519_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4e649c95ed85467a1748c7cb37421d3b9902d763 --- /dev/null +++ b/tasks/0018_038_18038519_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): +- CC GENERAL.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the variance of the PURCHASES feature 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/0018_038_18038519_qa_5/task.toml b/tasks/0018_038_18038519_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d6e19e8d62117839ebd743ef345865cfb416171b --- /dev/null +++ b/tasks/0018_038_18038519_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0018_038_18038519_qa_5" +description = "What is the variance of the PURCHASES feature in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0018/038/18038519.ipynb_qa_5" +kaggle_dataset_name = "arjunbhasin2013/ccdata" +gold_answer = "4565208.191108808" +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 = "arjunbhasin2013__ccdata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arjunbhasin2013/ccdata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4565208.191108808" +QUESTION = "What is the variance of the PURCHASES feature in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +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/0018_456_18456045_qa_5/instruction.md b/tasks/0018_456_18456045_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9d93431f78627b3352ad7d0a5a0e6fad9dabe4b6 --- /dev/null +++ b/tasks/0018_456_18456045_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference in test accuracy between the kNN and SVM models when using the 80/20 train/test split configuration? + +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/0018_456_18456045_qa_5/task.toml b/tasks/0018_456_18456045_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ac7bba7c0efe5e939f9f39b65f74bc700f321b78 --- /dev/null +++ b/tasks/0018_456_18456045_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0018_456_18456045_qa_5" +description = "What is the difference in test accuracy between the kNN and SVM models when using the 80/20 train/test split configuration?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0018/456/18456045.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "What is the difference in test accuracy between the kNN and SVM models when using the 80/20 train/test split configuration?" +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/0019_570_19570997_qa_1/instruction.md b/tasks/0019_570_19570997_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..41bd9378175b51a49856ea403d1e993c2fd5ddac --- /dev/null +++ b/tasks/0019_570_19570997_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: +How many districts in the dataset had missing values in the total_bedrooms column before imputation? + +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/0019_570_19570997_qa_1/task.toml b/tasks/0019_570_19570997_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e3b19bbcfa1e62657bed6a49c10ea4c15b360bcb --- /dev/null +++ b/tasks/0019_570_19570997_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0019_570_19570997_qa_1" +description = "How many districts in the dataset had missing values in the total_bedrooms column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0019/570/19570997.ipynb_qa_1" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "207" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "207" +QUESTION = "How many districts in the dataset had missing values in the total_bedrooms column before imputation?" +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/0019_978_19978878_qa_2/instruction.md b/tasks/0019_978_19978878_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..22308b7a3e9f2ff6c4c6e3f7b53bc05894dc60af --- /dev/null +++ b/tasks/0019_978_19978878_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: +Which Iris species is linearly separable from the other two according to the pairplot 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/0019_978_19978878_qa_2/task.toml b/tasks/0019_978_19978878_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bbea39045c1ff37e10f6b46047495e552e6274cd --- /dev/null +++ b/tasks/0019_978_19978878_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0019_978_19978878_qa_2" +description = "Which Iris species is linearly separable from the other two according to the pairplot analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0019/978/19978878.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-setosa" +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 = "Iris-setosa" +QUESTION = "Which Iris species is linearly separable from the other two according to the pairplot analysis?" +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/0020_216_20216126_qa_2/instruction.md b/tasks/0020_216_20216126_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..395522a0b52a533538bac3e294b860be588114d9 --- /dev/null +++ b/tasks/0020_216_20216126_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: +Which odor is most commonly associated with poisonous mushrooms 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/0020_216_20216126_qa_2/task.toml b/tasks/0020_216_20216126_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3e09111de63f5de3d0c0ce175c61c797a974421c --- /dev/null +++ b/tasks/0020_216_20216126_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0020_216_20216126_qa_2" +description = "Which odor is most commonly associated with poisonous mushrooms in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/216/20216126.ipynb_qa_2" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "Foul" +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__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Foul" +QUESTION = "Which odor is most commonly associated with poisonous mushrooms 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/0020_756_20756026_qa_2/instruction.md b/tasks/0020_756_20756026_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..33586c3ae5a1f03079b2d5a2c04a2e0f9bdf1b51 --- /dev/null +++ b/tasks/0020_756_20756026_qa_2/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): +- Train.csv +- Test.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 Outlet_Size column before imputation? + +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/0020_756_20756026_qa_2/task.toml b/tasks/0020_756_20756026_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..65cdfec09287b1055b5df70a95cf275e19629486 --- /dev/null +++ b/tasks/0020_756_20756026_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0020_756_20756026_qa_2" +description = "How many missing values were present in the Outlet_Size column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/756/20756026.ipynb_qa_2" +kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data" +gold_answer = "4016" +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 = "brijbhushannanda1979__bigmart-sales-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4016" +QUESTION = "How many missing values were present in the Outlet_Size column before imputation?" +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/0020_991_20991108_qa_5/instruction.md b/tasks/0020_991_20991108_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b1a1c5c7d6772bfb5815742b7671dbe7c9d58a65 --- /dev/null +++ b/tasks/0020_991_20991108_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): +- sensor_readings_24.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 test samples evaluated in the MLP model's confusion matrix output? + +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/0020_991_20991108_qa_5/task.toml b/tasks/0020_991_20991108_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..856ef09c927d86033970845893aebf041cdc663f --- /dev/null +++ b/tasks/0020_991_20991108_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0020_991_20991108_qa_5" +description = "What is the total number of test samples evaluated in the MLP model's confusion matrix output?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/991/20991108.ipynb_qa_5" +kaggle_dataset_name = "uciml/wall-following-robot" +gold_answer = "1637 samples" +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 = "uciml__wall-following-robot" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/wall-following-robot" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1637 samples" +QUESTION = "What is the total number of test samples evaluated in the MLP model's confusion matrix output? (Use a 70/30 train/test split with test_size=0.3)" +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/0021_030_21030697_qa_5/instruction.md b/tasks/0021_030_21030697_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c7619e7f3d5bdabff54362ac6e8169355557022b --- /dev/null +++ b/tasks/0021_030_21030697_qa_5/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): +- ks-projects-201801.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of projects in the original dataset were either failed or successful (excluding canceled, undefined, live, and suspended states)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a percentage (e.g. 95.5), not a fraction. + +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/0021_030_21030697_qa_5/task.toml b/tasks/0021_030_21030697_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e311a88554c281f1a90b819456396aaadebe82f9 --- /dev/null +++ b/tasks/0021_030_21030697_qa_5/task.toml @@ -0,0 +1,58 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0021_030_21030697_qa_5" +description = "What percentage of projects in the original dataset were either failed or successful (excluding canceled, undefined, live, and suspended states)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/030/21030697.ipynb_qa_5" +kaggle_dataset_name = "kemical/kickstarter-projects" +gold_answer = "87.6%" +reward_mode_initial = "flexible" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +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 = "kemical__kickstarter-projects" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kemical/kickstarter-projects" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "87.6%" +QUESTION = "What percentage of projects in the original dataset were either failed or successful (excluding canceled, undefined, live, and suspended states)?" +REWARD_MODE = "flexible" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0021_121_21121885_qa_3/instruction.md b/tasks/0021_121_21121885_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ea07ca2eba0acc7a3abc10fb759f28622cd35d28 --- /dev/null +++ b/tasks/0021_121_21121885_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): +- ted_main.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which four topics emerged as most prominent in the word cloud analysis of the larger dataset of unpopular TED talks (205 entries with high negative rating ratios)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the four topic names, in the order given. + +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/0021_121_21121885_qa_3/task.toml b/tasks/0021_121_21121885_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..631358eb096e8eb633a121e06b14d8874269e750 --- /dev/null +++ b/tasks/0021_121_21121885_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0021_121_21121885_qa_3" +description = "Which four topics emerged as most prominent in the word cloud analysis of the larger dataset of unpopular TED talks (205 entries with high negative rating ratios)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/121/21121885.ipynb_qa_3" +kaggle_dataset_name = "rounakbanik/ted-talks" +gold_answer = "Technology, design, culture, global issues" +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 = "rounakbanik__ted-talks" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rounakbanik/ted-talks" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Technology, design, culture, global issues" +QUESTION = "Which four topics emerged as most prominent in the word cloud analysis of the larger dataset of unpopular TED talks (205 entries with high negative rating ratios)?" +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/0021_193_21193214_qa_5/instruction.md b/tasks/0021_193_21193214_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..385e64b66bf0e921844e9f7b512ac732e149388e --- /dev/null +++ b/tasks/0021_193_21193214_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): +- oec.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 analyzing the relationship between log(PlanetaryMass) and log(Radius) of exoplanets? + +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/0021_193_21193214_qa_5/task.toml b/tasks/0021_193_21193214_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..38de3edde4e8bf97461fe0a045e6b7c6a11d51bc --- /dev/null +++ b/tasks/0021_193_21193214_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0021_193_21193214_qa_5" +description = "What is the coefficient of determination (R²) for the linear regression model analyzing the relationship between log(PlanetaryMass) and log(Radius) of exoplanets?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/193/21193214.ipynb_qa_5" +kaggle_dataset_name = "mrisdal/open-exoplanet-catalogue" +gold_answer = "0.7419577761281136" +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 = "mrisdal__open-exoplanet-catalogue" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mrisdal/open-exoplanet-catalogue" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.7419577761281136" +QUESTION = "What is the coefficient of determination (R²) for the linear regression model analyzing the relationship between log(PlanetaryMass) and log(Radius) of exoplanets?" +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/0021_299_21299002_qa_3/instruction.md b/tasks/0021_299_21299002_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..352551c6bd38df59ac80be07b946ce3f974edf7b --- /dev/null +++ b/tasks/0021_299_21299002_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): +- X.npy +- Y.npy + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Following the second train-test split with a test size of 20%, how many samples were allocated to the training set for the CNN 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/0021_299_21299002_qa_3/task.toml b/tasks/0021_299_21299002_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7c7d07328d07dc67a5cf01ce2886530be248e044 --- /dev/null +++ b/tasks/0021_299_21299002_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0021_299_21299002_qa_3" +description = "Following the second train-test split with a test size of 20%, how many samples were allocated to the training set for the CNN model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/299/21299002.ipynb_qa_3" +kaggle_dataset_name = "ardamavi/sign-language-digits-dataset" +gold_answer = "1649" +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 = "ardamavi__sign-language-digits-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ardamavi/sign-language-digits-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1649" +QUESTION = "Following the second train-test split with a test size of 20%, how many samples were allocated to the training set for the CNN model?" +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/0021_353_21353656_qa_1/instruction.md b/tasks/0021_353_21353656_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..27a9130f6e67666ce16ae509daf90e06909b83a1 --- /dev/null +++ b/tasks/0021_353_21353656_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 average alcohol content percentage among the three wine quality categories (bad, ok, good)? + +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/0021_353_21353656_qa_1/task.toml b/tasks/0021_353_21353656_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4b5d03d71e2061ce0e98984d5980e01022d61fb7 --- /dev/null +++ b/tasks/0021_353_21353656_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0021_353_21353656_qa_1" +description = "What is the highest average alcohol content percentage among the three wine quality categories (bad, ok, good)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/353/21353656.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "11.52" +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 = "11.52" +QUESTION = "What is the highest average alcohol content percentage among the three wine quality categories (bad, ok, good)?" +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/0021_643_21643452_qa_5/instruction.md b/tasks/0021_643_21643452_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..590f890b464b797f8f26da49d03c3f1ca2d45cc5 --- /dev/null +++ b/tasks/0021_643_21643452_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which currency has the highest proportion of successful projects in the dataset based on the heatmap visualization? + +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/0021_643_21643452_qa_5/task.toml b/tasks/0021_643_21643452_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d1d6510427b572fbb5f621a426cb14cf05c34dda --- /dev/null +++ b/tasks/0021_643_21643452_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0021_643_21643452_qa_5" +description = "Which currency has the highest proportion of successful projects in the dataset based on the heatmap visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/643/21643452.ipynb_qa_5" +kaggle_dataset_name = "kemical/kickstarter-projects" +gold_answer = "USD" +reward_mode_initial = "exact_short" +package_tier = 0 +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 = "kemical__kickstarter-projects" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kemical/kickstarter-projects" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "USD" +QUESTION = "Which currency has the highest proportion of successful projects in the dataset based on the heatmap visualization?" +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/0021_901_21901400_qa_3/instruction.md b/tasks/0021_901_21901400_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7f7baf05b55082e18722b90cdca29ddd531ad9a3 --- /dev/null +++ b/tasks/0021_901_21901400_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): +- ks-projects-201801.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which category type (main category vs. subcategory) shows greater influence on project success based on the feature importance 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/0021_901_21901400_qa_3/task.toml b/tasks/0021_901_21901400_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..87867198e034b44498316d70cd9af76e2d58418b --- /dev/null +++ b/tasks/0021_901_21901400_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0021_901_21901400_qa_3" +description = "Which category type (main category vs. subcategory) shows greater influence on project success based on the feature importance analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/901/21901400.ipynb_qa_3" +kaggle_dataset_name = "kemical/kickstarter-projects" +gold_answer = "subcategory" +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 = "kemical__kickstarter-projects" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kemical/kickstarter-projects" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "subcategory" +QUESTION = "Which category type (main category vs. subcategory) shows greater influence on project success based on the feature importance analysis?" +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/0021_960_21960570_qa_3/instruction.md b/tasks/0021_960_21960570_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8802233a21528bd949c9ef75649028965f03a0ff --- /dev/null +++ b/tasks/0021_960_21960570_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): +- auto-mpg.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the skewness of the mpg distribution before any transformation is 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/0021_960_21960570_qa_3/task.toml b/tasks/0021_960_21960570_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..373da908a6823f935a3f216f34db54a2ab384301 --- /dev/null +++ b/tasks/0021_960_21960570_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0021_960_21960570_qa_3" +description = "What is the skewness of the mpg distribution before any transformation is applied?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/960/21960570.ipynb_qa_3" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "0.46" +reward_mode_initial = "numeric" +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__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.46" +QUESTION = "What is the skewness of the mpg distribution before any transformation is applied?" +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/0021_960_21960570_qa_4/instruction.md b/tasks/0021_960_21960570_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..77dd29dedaf260e1c491e9e70169c3aff96020f6 --- /dev/null +++ b/tasks/0021_960_21960570_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): +- auto-mpg.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the skewness of the mpg distribution after applying the Box-Cox transformation? + +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/0021_960_21960570_qa_4/task.toml b/tasks/0021_960_21960570_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..802c9de0cc685a1a2741259290f7412c2a31369e --- /dev/null +++ b/tasks/0021_960_21960570_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0021_960_21960570_qa_4" +description = "What is the skewness of the mpg distribution after applying the Box-Cox transformation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/960/21960570.ipynb_qa_4" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "-0.02" +reward_mode_initial = "numeric" +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 = "uciml__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "-0.02" +QUESTION = "What is the skewness of the mpg distribution after applying the Box-Cox transformation?" +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_193_22193578_qa_5/instruction.md b/tasks/0022_193_22193578_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..44fbe6bd0513672ecf4fe10a2f003b118e7ce89e --- /dev/null +++ b/tasks/0022_193_22193578_qa_5/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): +- glass.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the original dataset (pre-transformation) has the highest kurtosis value, and what is that value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, keep decimals). + +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_193_22193578_qa_5/task.toml b/tasks/0022_193_22193578_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4bcdfe83cfb1b14513c43836a114f029df164d30 --- /dev/null +++ b/tasks/0022_193_22193578_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0022_193_22193578_qa_5" +description = "Which feature in the original dataset (pre-transformation) has the highest kurtosis value, and what is that value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0022/193/22193578.ipynb_qa_5" +kaggle_dataset_name = "uciml/glass" +gold_answer = "K with 54.689699" +reward_mode_initial = "flexible" +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__glass" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/glass" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "K with 54.689699" +QUESTION = "Which feature in the original dataset (pre-transformation) has the highest kurtosis value, and what is that value?" +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/0022_704_22704559_qa_4/instruction.md b/tasks/0022_704_22704559_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..94f629ea68ef94bac1031500bd8217b4b7f8188e --- /dev/null +++ b/tasks/0022_704_22704559_qa_4/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): +- 2015.csv +- 2016.csv +- 2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which region in 2016 has the lowest median GDP per Capita according to the grouped median 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/0022_704_22704559_qa_4/task.toml b/tasks/0022_704_22704559_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b8d6b981c7cf32ae561fcc205f0bf43b0f5a1c77 --- /dev/null +++ b/tasks/0022_704_22704559_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0022_704_22704559_qa_4" +description = "Which region in 2016 has the lowest median GDP per Capita according to the grouped median analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0022/704/22704559.ipynb_qa_4" +kaggle_dataset_name = "unsdsn/world-happiness" +gold_answer = "Sub-Saharan Africa" +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 = "unsdsn__world-happiness" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "unsdsn/world-happiness" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Sub-Saharan Africa" +QUESTION = "Which region in 2016 has the lowest median GDP per Capita according to the grouped median analysis?" +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/0022_886_22886038_qa_4/instruction.md b/tasks/0022_886_22886038_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7c461d1d69e957eff947b0e5d2d41be94258f3c8 --- /dev/null +++ b/tasks/0022_886_22886038_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 highest cross-validation accuracy achieved through the grid search 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/0022_886_22886038_qa_4/task.toml b/tasks/0022_886_22886038_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e8016f7566b1123e92724933a4143ae04a13a9be --- /dev/null +++ b/tasks/0022_886_22886038_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0022_886_22886038_qa_4" +description = "What is the highest cross-validation accuracy achieved through the grid search process?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0022/886/22886038.ipynb_qa_4" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.9812" +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 = "0.9812" +QUESTION = "What is the highest cross-validation accuracy achieved through the grid search process?" +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/0022_916_22916338_qa_5/instruction.md b/tasks/0022_916_22916338_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..de7c54df3e1e01bc088503ef0b73e7a071caf22d --- /dev/null +++ b/tasks/0022_916_22916338_qa_5/instruction.md @@ -0,0 +1,20 @@ +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): +- uber-raw-data-apr14.csv +- uber-raw-data-may14.csv +- uber-raw-data-jun14.csv +- uber-raw-data-jul14.csv +- uber-raw-data-aug14.csv +- uber-raw-data-sep14.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest number of Uber pickups recorded in a single hour according to the first 20 entries of the hourly 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/0022_916_22916338_qa_5/task.toml b/tasks/0022_916_22916338_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6f1f4d5e7452d3895f74fcf8424208834e284f85 --- /dev/null +++ b/tasks/0022_916_22916338_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0022_916_22916338_qa_5" +description = "What is the highest number of Uber pickups recorded in a single hour according to the first 20 entries of the hourly data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0022/916/22916338.ipynb_qa_5" +kaggle_dataset_name = "fivethirtyeight/uber-pickups-in-new-york-city" +gold_answer = "1262" +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 = "fivethirtyeight__uber-pickups-in-new-york-city" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "fivethirtyeight/uber-pickups-in-new-york-city" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1262" +QUESTION = "What is the highest number of Uber pickups recorded in a single hour according to the first 20 entries of the hourly 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] diff --git a/tasks/0023_468_23468316_qa_2/instruction.md b/tasks/0023_468_23468316_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0be4cbc3fd51768af95b5f0ec3e7ec5fbd0f6998 --- /dev/null +++ b/tasks/0023_468_23468316_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent occupation category 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/0023_468_23468316_qa_2/task.toml b/tasks/0023_468_23468316_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4bb6075e025bceb1d651891f898da6e8cc28f882 --- /dev/null +++ b/tasks/0023_468_23468316_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0023_468_23468316_qa_2" +description = "What is the most frequent occupation category in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/468/23468316.ipynb_qa_2" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "Prof-specialty" +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 = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Prof-specialty" +QUESTION = "What is the most frequent occupation category 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/0023_583_23583710_qa_4/instruction.md b/tasks/0023_583_23583710_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0e530d9411d3396082d0c7104afcac7119ac5245 --- /dev/null +++ b/tasks/0023_583_23583710_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): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many Mega Pokémon in the dataset are classified as legendary? + +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/0023_583_23583710_qa_4/task.toml b/tasks/0023_583_23583710_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0e38541ede518dfe04357fc328081887ebe5518a --- /dev/null +++ b/tasks/0023_583_23583710_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0023_583_23583710_qa_4" +description = "How many Mega Pokémon in the dataset are classified as legendary?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/583/23583710.ipynb_qa_4" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "6" +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 = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many Mega Pokémon in the dataset are classified as legendary?" +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/0023_721_23721684_qa_4/instruction.md b/tasks/0023_721_23721684_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e57fa3a6c5d66b9eb9a88648315dce8b2d6c1e6e --- /dev/null +++ b/tasks/0023_721_23721684_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): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many cereals in the dataset are classified as hot cereals? + +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/0023_721_23721684_qa_4/task.toml b/tasks/0023_721_23721684_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bc16d248189d6b8a0a87b779ab1c7b21eb3ed335 --- /dev/null +++ b/tasks/0023_721_23721684_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0023_721_23721684_qa_4" +description = "How many cereals in the dataset are classified as hot cereals?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/721/23721684.ipynb_qa_4" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "3" +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 = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many cereals in the dataset are classified as hot cereals?" +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/0023_846_23846255_qa_1/instruction.md b/tasks/0023_846_23846255_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..16051bda1659f8a4b4a3bbf73171d57bbf1d5cd9 --- /dev/null +++ b/tasks/0023_846_23846255_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: +What is the absolute difference between the maximum purchase amount and the 75th percentile purchase amount 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/0023_846_23846255_qa_1/task.toml b/tasks/0023_846_23846255_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dd0e35fa371a0fc0ef965d7e7274727c2e2ed720 --- /dev/null +++ b/tasks/0023_846_23846255_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0023_846_23846255_qa_1" +description = "What is the absolute difference between the maximum purchase amount and the 75th percentile purchase amount in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/846/23846255.ipynb_qa_1" +kaggle_dataset_name = "sdolezel/black-friday" +gold_answer = "11907.00" +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 = "sdolezel__black-friday" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sdolezel/black-friday" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11907.00" +QUESTION = "What is the absolute difference between the maximum purchase amount and the 75th percentile purchase amount 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/0023_990_23990837_qa_5/instruction.md b/tasks/0023_990_23990837_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cba12ea2a9c177011aa1b760c81f19066ae5aada --- /dev/null +++ b/tasks/0023_990_23990837_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): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the 25th percentile value for the 'smoothness_mean' feature 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/0023_990_23990837_qa_5/task.toml b/tasks/0023_990_23990837_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..53d835ba0ee6d13984b693c50d224a0d817ca221 --- /dev/null +++ b/tasks/0023_990_23990837_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0023_990_23990837_qa_5" +description = "What is the 25th percentile value for the 'smoothness_mean' feature in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/990/23990837.ipynb_qa_5" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.086370" +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__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 = "0.086370" +QUESTION = "What is the 25th percentile value for the 'smoothness_mean' feature 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/0024_081_24081260_qa_3/instruction.md b/tasks/0024_081_24081260_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..241ed97c2246eee234c19dc08080a21c83f99583 --- /dev/null +++ b/tasks/0024_081_24081260_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature pair (Sepal Length vs Sepal Width or Petal Length vs Petal Width) shows better separation between species based on the scatter plots? + +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/0024_081_24081260_qa_3/task.toml b/tasks/0024_081_24081260_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a57c4cdb84f33a38a4baadd4a53e2b50d9ba0f0a --- /dev/null +++ b/tasks/0024_081_24081260_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0024_081_24081260_qa_3" +description = "Which feature pair (Sepal Length vs Sepal Width or Petal Length vs Petal Width) shows better separation between species based on the scatter plots?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/081/24081260.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Petal Length vs Petal Width" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Petal Length vs Petal Width" +QUESTION = "Which feature pair (Sepal Length vs Sepal Width or Petal Length vs Petal Width) shows better separation between species based on the scatter plots?" +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/0024_275_24275657_qa_5/instruction.md b/tasks/0024_275_24275657_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..67fd3c1d5b8b2b76725483edb18f1cd4723de005 --- /dev/null +++ b/tasks/0024_275_24275657_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of variance is explained by the second principal component in the PCA analysis of 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/0024_275_24275657_qa_5/task.toml b/tasks/0024_275_24275657_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f9866bbbb21d50a3e9c6b64667e047af5a013e49 --- /dev/null +++ b/tasks/0024_275_24275657_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0024_275_24275657_qa_5" +description = "What percentage of variance is explained by the second principal component in the PCA analysis of the Iris dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/275/24275657.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "23.03" +reward_mode_initial = "numeric" +package_tier = 0 +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 = "23.03" +QUESTION = "What percentage of variance is explained by the second principal component in the PCA analysis of the Iris 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/0024_658_24658460_qa_5/instruction.md b/tasks/0024_658_24658460_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4f0125743ff29d0b1ca5ca4cb3a243974a749691 --- /dev/null +++ b/tasks/0024_658_24658460_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: +How many unique data columns are present in the dataset according to the provided information? + +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/0024_658_24658460_qa_5/task.toml b/tasks/0024_658_24658460_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9c64162799dd8ea44853b8bb322b6893fd4ca5ad --- /dev/null +++ b/tasks/0024_658_24658460_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0024_658_24658460_qa_5" +description = "How many unique data columns are present in the dataset according to the provided information?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/658/24658460.ipynb_qa_5" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "11" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11" +QUESTION = "How many unique data columns are present in the dataset according to the provided information?" +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/0024_796_24796579_qa_1/instruction.md b/tasks/0024_796_24796579_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..989b08473c572ca726cae0436b3fd02e4b056f61 --- /dev/null +++ b/tasks/0024_796_24796579_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): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the ratio of ham to spam messages 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/0024_796_24796579_qa_1/task.toml b/tasks/0024_796_24796579_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..49cf445ea3e0ae87a741b6c15b1b12e54aff013e --- /dev/null +++ b/tasks/0024_796_24796579_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0024_796_24796579_qa_1" +description = "What is the ratio of ham to spam messages in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/796/24796579.ipynb_qa_1" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "6.5" +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__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 = "6.5" +QUESTION = "What is the ratio of ham to spam messages 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/0024_991_24991983_qa_2/instruction.md b/tasks/0024_991_24991983_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8c819336565747377b116d670aef1572000a12af --- /dev/null +++ b/tasks/0024_991_24991983_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): +- (see /home/user/input) + +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 two features in the dataset according to the heatmap visualization? + +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/0024_991_24991983_qa_2/task.toml b/tasks/0024_991_24991983_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a28c696748d3a2b1c782e9fbe4fb3629e6894783 --- /dev/null +++ b/tasks/0024_991_24991983_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0024_991_24991983_qa_2" +description = "What is the highest correlation coefficient between any two features in the dataset according to the heatmap visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/991/24991983.ipynb_qa_2" +kaggle_dataset_name = "yuqing01/breast-cancer" +gold_answer = "0.98" +reward_mode_initial = "numeric" +package_tier = 0 +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 = "yuqing01__breast-cancer" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "yuqing01/breast-cancer" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.98" +QUESTION = "What is the highest correlation coefficient between any two features in the dataset according to the heatmap visualization?" +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/0026_293_26293551_qa_3/instruction.md b/tasks/0026_293_26293551_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0dcc7adc1ea6a600474a463f690108510199ff56 --- /dev/null +++ b/tasks/0026_293_26293551_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: +What is the average age of patients in the dataset based on the preprocessed 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/0026_293_26293551_qa_3/task.toml b/tasks/0026_293_26293551_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f445347dc4414175a869362b1f51d89ec2473799 --- /dev/null +++ b/tasks/0026_293_26293551_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0026_293_26293551_qa_3" +description = "What is the average age of patients in the dataset based on the preprocessed data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/293/26293551.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "33.24" +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 = "33.24" +QUESTION = "What is the average age of patients in the dataset based on the preprocessed data?" +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/0026_551_26551206_qa_3/instruction.md b/tasks/0026_551_26551206_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5fb798b3b4dade537d0f7a8e93d670395729ca4d --- /dev/null +++ b/tasks/0026_551_26551206_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): +- breastCancer.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the precision score for class 1 (malignant tumors) when using K=11 in the KNN 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/0026_551_26551206_qa_3/task.toml b/tasks/0026_551_26551206_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..41ae8103aaf15b3d6dddf9021315927aef63aada --- /dev/null +++ b/tasks/0026_551_26551206_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0026_551_26551206_qa_3" +description = "What is the precision score for class 1 (malignant tumors) when using K=11 in the KNN model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/551/26551206.ipynb_qa_3" +kaggle_dataset_name = "jiuzhang/ninechapter-breastcancer" +gold_answer = "0.98" +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 = "jiuzhang__ninechapter-breastcancer" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "jiuzhang/ninechapter-breastcancer" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.98" +QUESTION = "What is the precision score for class 1 (malignant tumors) when using K=11 in the KNN 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/0026_895_26895005_qa_1/instruction.md b/tasks/0026_895_26895005_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..397ce14110580b95465db272a82c2570913045e1 --- /dev/null +++ b/tasks/0026_895_26895005_qa_1/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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the ratio of class 0 samples to class 1 samples in the original income dataset before applying any imbalance correction techniques? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a ratio in the form :1, with the value as a plain number (e.g., 3.18). + +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/0026_895_26895005_qa_1/task.toml b/tasks/0026_895_26895005_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..31ac14f4c69653f983edce127f73a5b0db687e10 --- /dev/null +++ b/tasks/0026_895_26895005_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0026_895_26895005_qa_1" +description = "What is the ratio of class 0 samples to class 1 samples in the original income dataset before applying any imbalance correction techniques?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/895/26895005.ipynb_qa_1" +kaggle_dataset_name = "wenruliu/adult-income-dataset" +gold_answer = "3.18:1" +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 = "wenruliu__adult-income-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wenruliu/adult-income-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3.18:1" +QUESTION = "What is the ratio of class 0 samples to class 1 samples in the original income dataset before applying any imbalance correction techniques?" +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/0026_997_26997571_qa_5/instruction.md b/tasks/0026_997_26997571_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2b03ff15697b984cfc61260ea2bac6319007859e --- /dev/null +++ b/tasks/0026_997_26997571_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): +- winemag-data_first150k.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which country ranks third in the average wine points hierarchy? + +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/0026_997_26997571_qa_5/task.toml b/tasks/0026_997_26997571_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0d56cf4d0dd69fc098bc030ac7a9bffb7e8a6828 --- /dev/null +++ b/tasks/0026_997_26997571_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0026_997_26997571_qa_5" +description = "Which country ranks third in the average wine points hierarchy?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/997/26997571.ipynb_qa_5" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "France" +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 = "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 ranks third in the average wine points hierarchy?" +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/0028_443_28443310_qa_5/instruction.md b/tasks/0028_443_28443310_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..14709defe414345d1d040cc3d0da1102cd3511a7 --- /dev/null +++ b/tasks/0028_443_28443310_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): +- pokemon_alopez247.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between "Height_m" and "Weight_kg" 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/0028_443_28443310_qa_5/task.toml b/tasks/0028_443_28443310_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e437600d8f62ca5a282ade052235713e077e5d62 --- /dev/null +++ b/tasks/0028_443_28443310_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0028_443_28443310_qa_5" +description = "What is the correlation coefficient between \"Height_m\" and \"Weight_kg\" in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/443/28443310.ipynb_qa_5" +kaggle_dataset_name = "alopez247/pokemon" +gold_answer = "0.661" +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 = "alopez247__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "alopez247/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.661" +QUESTION = "What is the correlation coefficient between \"Height_m\" and \"Weight_kg\" 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/0028_492_28492741_qa_1/instruction.md b/tasks/0028_492_28492741_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..309f043f118f39f05a045d4fda543637bc4acafc --- /dev/null +++ b/tasks/0028_492_28492741_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): +- emails.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 Logistic Regression model on the test set after training with TF-IDF features? + +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/0028_492_28492741_qa_1/task.toml b/tasks/0028_492_28492741_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b1613087fe941795d20e70fb78df7b778896e11a --- /dev/null +++ b/tasks/0028_492_28492741_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0028_492_28492741_qa_1" +description = "What is the accuracy of the Logistic Regression model on the test set after training with TF-IDF features?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/492/28492741.ipynb_qa_1" +kaggle_dataset_name = "karthickveerakumar/spam-filter" +gold_answer = "0.9784758580570099" +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__spam-filter" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "karthickveerakumar/spam-filter" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.9784758580570099" +QUESTION = "What is the accuracy of the Logistic Regression model on the test set after training with TF-IDF features?" +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/0028_862_28862512_qa_4/instruction.md b/tasks/0028_862_28862512_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7998261e2f324e47643a76f0eeaf351e9432c765 --- /dev/null +++ b/tasks/0028_862_28862512_qa_4/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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which genre(s) are most common among the top-selling video games (global sales >20 million)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact genre names. + +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/0028_862_28862512_qa_4/task.toml b/tasks/0028_862_28862512_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0f067d2f5ed6f5ecf272f4fc7c7992f0349c1b12 --- /dev/null +++ b/tasks/0028_862_28862512_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0028_862_28862512_qa_4" +description = "Which genre(s) are most common among the top-selling video games (global sales >20 million)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/862/28862512.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Sports, Platform" +reward_mode_initial = "list" +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 = "Sports, Platform" +QUESTION = "Which genre(s) are most common among the top-selling video games (global sales >20 million)?" +REWARD_MODE = "list_csv" +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/0029_200_29200364_qa_1/instruction.md b/tasks/0029_200_29200364_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..adcd1ca4f8f39f0b2aac3492704786254edee42c --- /dev/null +++ b/tasks/0029_200_29200364_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: +How many unique species are present in 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/0029_200_29200364_qa_1/task.toml b/tasks/0029_200_29200364_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..448601d3cf4f9bbfb52150f42f80d07107bd6bf6 --- /dev/null +++ b/tasks/0029_200_29200364_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0029_200_29200364_qa_1" +description = "How many unique species are present in the Iris dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0029/200/29200364.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "3" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many unique species are present in 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/0029_204_29204719_qa_2/instruction.md b/tasks/0029_204_29204719_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b09650d570bd244c2598a2b093c2db4074f35e74 --- /dev/null +++ b/tasks/0029_204_29204719_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): +- Restaurant_Reviews.tsv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many true positive predictions did the Naive Bayes classifier make on the test set according to the confusion 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/0029_204_29204719_qa_2/task.toml b/tasks/0029_204_29204719_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b47dd6aa56ea3abeace6b7810113484c04d1ada0 --- /dev/null +++ b/tasks/0029_204_29204719_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0029_204_29204719_qa_2" +description = "How many true positive predictions did the Naive Bayes classifier make on the test set according to the confusion matrix?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0029/204/29204719.ipynb_qa_2" +kaggle_dataset_name = "hj5992/restaurantreviews" +gold_answer = "91" +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 = "hj5992__restaurantreviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hj5992/restaurantreviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "91" +QUESTION = "How many true positive predictions did the Naive Bayes classifier make on the test set according to the confusion matrix?" +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/0029_558_29558970_qa_2/instruction.md b/tasks/0029_558_29558970_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b8aea4daf8329198b745db94f2e52cc68fac9f17 --- /dev/null +++ b/tasks/0029_558_29558970_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): +- combats.csv +- tests.csv +- pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Pokémon has the highest win percentage 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/0029_558_29558970_qa_2/task.toml b/tasks/0029_558_29558970_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9a40d9e22235836f2d284f646522a4453305c9f2 --- /dev/null +++ b/tasks/0029_558_29558970_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0029_558_29558970_qa_2" +description = "Which Pokémon has the highest win percentage in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0029/558/29558970.ipynb_qa_2" +kaggle_dataset_name = "terminus7/pokemon-challenge" +gold_answer = "Mega Aerodactyl" +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 = "terminus7__pokemon-challenge" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Mega Aerodactyl" +QUESTION = "Which Pokémon has the highest win percentage 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/0029_784_29784165_qa_1/instruction.md b/tasks/0029_784_29784165_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7d6d9f5efd44714934dc52d8535d4d0b10136c59 --- /dev/null +++ b/tasks/0029_784_29784165_qa_1/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: +Which two features in the Iris dataset exhibit the highest positive correlation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact column names. + +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/0029_784_29784165_qa_1/task.toml b/tasks/0029_784_29784165_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b3380929a695288859ef3f94f6ee5e31fee706a2 --- /dev/null +++ b/tasks/0029_784_29784165_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0029_784_29784165_qa_1" +description = "Which two features in the Iris dataset exhibit the highest positive correlation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0029/784/29784165.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalLengthCm, PetalWidthCm" +reward_mode_initial = "list" +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 = "PetalLengthCm, PetalWidthCm" +QUESTION = "Which two features in the Iris dataset exhibit the highest positive correlation?" +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/0030_817_30817038_qa_2/instruction.md b/tasks/0030_817_30817038_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..145d75a8d92a2111c5c8be039feee6c3019b4e69 --- /dev/null +++ b/tasks/0030_817_30817038_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): +- housing.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 missing values across all columns 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/0030_817_30817038_qa_2/task.toml b/tasks/0030_817_30817038_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..07f4206f078624fa3f300df8a911677197bbb268 --- /dev/null +++ b/tasks/0030_817_30817038_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0030_817_30817038_qa_2" +description = "What is the total number of missing values across all columns in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/817/30817038.ipynb_qa_2" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "207" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "207" +QUESTION = "What is the total number of missing values across all columns 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/0030_890_30890976_qa_4/instruction.md b/tasks/0030_890_30890976_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cb93f6af23292c67504fe6ba0e0ec08ad39491f2 --- /dev/null +++ b/tasks/0030_890_30890976_qa_4/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): +- train.csv +- test.csv +- gender_submission.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which embarkation port (S, C, or Q) has the highest frequency in the training 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/0030_890_30890976_qa_4/task.toml b/tasks/0030_890_30890976_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..57dc9f55228658215b8a334231562334aa9b8c08 --- /dev/null +++ b/tasks/0030_890_30890976_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0030_890_30890976_qa_4" +description = "Which embarkation port (S, C, or Q) has the highest frequency in the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/890/30890976.ipynb_qa_4" +kaggle_dataset_name = "rashigoel/titanic-machine-learning-from-disaster" +gold_answer = "S" +reward_mode_initial = "exact_short" +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 = "rashigoel__titanic-machine-learning-from-disaster" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rashigoel/titanic-machine-learning-from-disaster" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "S" +QUESTION = "Which embarkation port (S, C, or Q) has the highest frequency in the training 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/0030_991_30991339_qa_3/instruction.md b/tasks/0030_991_30991339_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..78a113c14f617f37ffa3e864712fa105d2f69320 --- /dev/null +++ b/tasks/0030_991_30991339_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): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the chi-squared score for the feature "ram" in the Univariate Selection 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/0030_991_30991339_qa_3/task.toml b/tasks/0030_991_30991339_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c8afe9e21e5ba31004815eb0f497aeabd32f96b4 --- /dev/null +++ b/tasks/0030_991_30991339_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0030_991_30991339_qa_3" +description = "What is the chi-squared score for the feature \"ram\" in the Univariate Selection analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/991/30991339.ipynb_qa_3" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "931267.519053" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "931267.519053" +QUESTION = "What is the chi-squared score for the feature \"ram\" in the Univariate Selection analysis?" +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/0030_991_30991339_qa_4/instruction.md b/tasks/0030_991_30991339_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..513d98a94ff740133580c27934b141d0c7ad1abb --- /dev/null +++ b/tasks/0030_991_30991339_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): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the feature importance score for the feature "clock_speed" according to the ExtraTreesClassifier 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/0030_991_30991339_qa_4/task.toml b/tasks/0030_991_30991339_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..eaac3dbf89addbaefe43627030ea18a82985cc11 --- /dev/null +++ b/tasks/0030_991_30991339_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0030_991_30991339_qa_4" +description = "What is the feature importance score for the feature \"clock_speed\" according to the ExtraTreesClassifier model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/991/30991339.ipynb_qa_4" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "0.03285815" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.03285815" +QUESTION = "What is the feature importance score for the feature \"clock_speed\" according to the ExtraTreesClassifier model?" +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/0031_033_31033882_qa_1/instruction.md b/tasks/0031_033_31033882_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1880c1230120da371385e9d2e8ef6c72be285453 --- /dev/null +++ b/tasks/0031_033_31033882_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): +- bank.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between the duration of contact and the deposit 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/0031_033_31033882_qa_1/task.toml b/tasks/0031_033_31033882_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e58f35c8c9acb4b85474cc3bc52f21ace1930575 --- /dev/null +++ b/tasks/0031_033_31033882_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0031_033_31033882_qa_1" +description = "What is the correlation coefficient between the duration of contact and the deposit outcome in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/033/31033882.ipynb_qa_1" +kaggle_dataset_name = "janiobachmann/bank-marketing-dataset" +gold_answer = "0.451919" +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 = "janiobachmann__bank-marketing-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.451919" +QUESTION = "What is the correlation coefficient between the duration of contact and the deposit 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/0031_128_31128554_qa_3/instruction.md b/tasks/0031_128_31128554_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..22756145d9214b3127ff6b61992fc1c2f50dadb8 --- /dev/null +++ b/tasks/0031_128_31128554_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: +Which variable exhibits the highest degree of positive 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/0031_128_31128554_qa_3/task.toml b/tasks/0031_128_31128554_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bb2df39acbe8dabd3c669ffcf120cb87953451dd --- /dev/null +++ b/tasks/0031_128_31128554_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0031_128_31128554_qa_3" +description = "Which variable exhibits the highest degree of positive skewness in its distribution?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/128/31128554.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Insulin" +reward_mode_initial = "exact_short" +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 = "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 = "Insulin" +QUESTION = "Which variable exhibits the highest degree of positive 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/0031_395_31395077_qa_1/instruction.md b/tasks/0031_395_31395077_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..31fb7e8bb212d28b63f1f2edff2ad9c77b143ab8 --- /dev/null +++ b/tasks/0031_395_31395077_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset exhibits the highest positive skewness based on the skewness values calculated? + +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_395_31395077_qa_1/task.toml b/tasks/0031_395_31395077_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..365de9d3cdfdde4d24a3d36a60738f6e0e7f1485 --- /dev/null +++ b/tasks/0031_395_31395077_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0031_395_31395077_qa_1" +description = "Which feature in the dataset exhibits the highest positive skewness based on the skewness values calculated?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/395/31395077.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Insulin" +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__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 = "Insulin" +QUESTION = "Which feature in the dataset exhibits the highest positive skewness based on the skewness values calculated?" +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/0031_757_31757076_qa_3/instruction.md b/tasks/0031_757_31757076_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3f9607c9c5e57d473922a5cdc2168b8c341e585e --- /dev/null +++ b/tasks/0031_757_31757076_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): +- weatherHistory.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average apparent temperature in April 2006 according to the monthly resampled 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/0031_757_31757076_qa_3/task.toml b/tasks/0031_757_31757076_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..186c7d71ee3f1e16f6979bbc1384af61b58f9372 --- /dev/null +++ b/tasks/0031_757_31757076_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0031_757_31757076_qa_3" +description = "What is the average apparent temperature in April 2006 according to the monthly resampled data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/757/31757076.ipynb_qa_3" +kaggle_dataset_name = "muthuj7/weather-dataset" +gold_answer = "12.098827" +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 = "muthuj7__weather-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "muthuj7/weather-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "12.098827" +QUESTION = "What is the average apparent temperature in April 2006 according to the monthly resampled data?" +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/0031_987_31987709_qa_1/instruction.md b/tasks/0031_987_31987709_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fdd086bbace4d20dc7acca56148e62a6443b6049 --- /dev/null +++ b/tasks/0031_987_31987709_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest positive correlation between any feature and the diabetes 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/0031_987_31987709_qa_1/task.toml b/tasks/0031_987_31987709_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..36beedb02d94021678b8a3ff06773cfd43654fc1 --- /dev/null +++ b/tasks/0031_987_31987709_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0031_987_31987709_qa_1" +description = "What is the highest positive correlation between any feature and the diabetes outcome in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/987/31987709.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0.46" +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.46" +QUESTION = "What is the highest positive correlation between any feature and the diabetes outcome 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/0032_071_32071401_qa_5/instruction.md b/tasks/0032_071_32071401_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..82a39285b353dbe312602d93b10c4a8ba1c1c8b2 --- /dev/null +++ b/tasks/0032_071_32071401_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which species has the highest median petal width based on the violin plot visualization? + +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_071_32071401_qa_5/task.toml b/tasks/0032_071_32071401_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c57c5d9c8a2a3c2841fe618094684b9a974cd02b --- /dev/null +++ b/tasks/0032_071_32071401_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0032_071_32071401_qa_5" +description = "Which species has the highest median petal width based on the violin plot visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/071/32071401.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-virginica" +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 = "Iris-virginica" +QUESTION = "Which species has the highest median petal width based on the violin plot visualization?" +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/0032_101_32101676_qa_2/instruction.md b/tasks/0032_101_32101676_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0faf43ad8136996c710c27b61e1f2544304ece6a --- /dev/null +++ b/tasks/0032_101_32101676_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): +- Test.csv +- Train.csv +- Submission.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which outlet type has the highest total Item_Outlet_Sales across all records in the training 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/0032_101_32101676_qa_2/task.toml b/tasks/0032_101_32101676_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6939d2fc395c3a7e01c3fb277ba044228b8f879f --- /dev/null +++ b/tasks/0032_101_32101676_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0032_101_32101676_qa_2" +description = "Which outlet type has the highest total Item_Outlet_Sales across all records in the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/101/32101676.ipynb_qa_2" +kaggle_dataset_name = "devashish0507/big-mart-sales-prediction" +gold_answer = "Supermarket Type1" +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 = "devashish0507__big-mart-sales-prediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "devashish0507/big-mart-sales-prediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Supermarket Type1" +QUESTION = "Which outlet type has the highest total Item_Outlet_Sales across all records in the training 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/0032_211_32211559_qa_5/instruction.md b/tasks/0032_211_32211559_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cbd60a7851ad8c1b79e57ba5b87e45410b196c52 --- /dev/null +++ b/tasks/0032_211_32211559_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): +- auto-mpg.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many vehicles in the dataset originally had missing values in the horsepower column before imputation? + +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_211_32211559_qa_5/task.toml b/tasks/0032_211_32211559_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ae364065133604b116dfd0f0e1248f400a22e027 --- /dev/null +++ b/tasks/0032_211_32211559_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_211_32211559_qa_5" +description = "How many vehicles in the dataset originally had missing values in the horsepower column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/211/32211559.ipynb_qa_5" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "6" +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__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many vehicles in the dataset originally had missing values in the horsepower column before imputation?" +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/0032_314_32314190_qa_3/instruction.md b/tasks/0032_314_32314190_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..82e68d3dddf853ea551ddeb5b897c80169aedc0d --- /dev/null +++ b/tasks/0032_314_32314190_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): +- student-mat.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common frequency of weekly alcohol consumption (Walc) among students based on the distribution 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/0032_314_32314190_qa_3/task.toml b/tasks/0032_314_32314190_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4984a60448773b695e77e36feb1957199cb1d44c --- /dev/null +++ b/tasks/0032_314_32314190_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0032_314_32314190_qa_3" +description = "What is the most common frequency of weekly alcohol consumption (Walc) among students based on the distribution analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/314/32314190.ipynb_qa_3" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "1" +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__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "What is the most common frequency of weekly alcohol consumption (Walc) among students based on the distribution analysis?" +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/0032_314_32314190_qa_4/instruction.md b/tasks/0032_314_32314190_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4a944ffb2be8718015d7aee6c9265ba060420a3a --- /dev/null +++ b/tasks/0032_314_32314190_qa_4/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): +- student-mat.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Walc frequency group shows the highest range of first-grade scores (G1), and what is the observed grade range? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, group first, range as a plain integer). + +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_314_32314190_qa_4/task.toml b/tasks/0032_314_32314190_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4a6fd3f7d5abd457a12eb827c80c24eda3f0ca97 --- /dev/null +++ b/tasks/0032_314_32314190_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0032_314_32314190_qa_4" +description = "Which Walc frequency group shows the highest range of first-grade scores (G1), and what is the observed grade range?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/314/32314190.ipynb_qa_4" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "1, 15" +reward_mode_initial = "list" +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__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1, 15" +QUESTION = "Which Walc frequency group shows the highest range of first-grade scores (G1), and what is the observed grade range?" +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/0032_386_32386426_qa_3/instruction.md b/tasks/0032_386_32386426_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..66ff03abaf08b2b3dbc1949540b2efe0169a1f38 --- /dev/null +++ b/tasks/0032_386_32386426_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): +- bank.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which marital status category demonstrates the highest proportion of term deposit subscriptions according to the visual 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/0032_386_32386426_qa_3/task.toml b/tasks/0032_386_32386426_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7824d8524b9c01dc8eda9c35b8243658c0419430 --- /dev/null +++ b/tasks/0032_386_32386426_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_386_32386426_qa_3" +description = "Which marital status category demonstrates the highest proportion of term deposit subscriptions according to the visual analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/386/32386426.ipynb_qa_3" +kaggle_dataset_name = "janiobachmann/bank-marketing-dataset" +gold_answer = "Single" +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 = "janiobachmann__bank-marketing-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Single" +QUESTION = "Which marital status category demonstrates the highest proportion of term deposit subscriptions according to the visual analysis?" +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/0032_488_32488845_qa_3/instruction.md b/tasks/0032_488_32488845_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..01075afaf2ca2d012a7452471aec629980fcf732 --- /dev/null +++ b/tasks/0032_488_32488845_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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which gender has a higher attrition rate according to the dataset 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/0032_488_32488845_qa_3/task.toml b/tasks/0032_488_32488845_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..02b772ea0cc8f12723900eec3e3529a1bdd41ace --- /dev/null +++ b/tasks/0032_488_32488845_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_488_32488845_qa_3" +description = "Which gender has a higher attrition rate according to the dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/488/32488845.ipynb_qa_3" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "Male" +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 = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Male" +QUESTION = "Which gender has a higher attrition rate according to the dataset analysis?" +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/0032_553_32553847_qa_5/instruction.md b/tasks/0032_553_32553847_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..de3d4fa36377dc8ec86a17ee2d26f3d58e4eff31 --- /dev/null +++ b/tasks/0032_553_32553847_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: +Do the histograms of message lengths indicate that spam messages tend to have longer character counts than ham messages? + +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_553_32553847_qa_5/task.toml b/tasks/0032_553_32553847_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5a21861af8b1a41f6e7e88afc28fb03fdbc22eb5 --- /dev/null +++ b/tasks/0032_553_32553847_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_553_32553847_qa_5" +description = "Do the histograms of message lengths indicate that spam messages tend to have longer character counts than ham messages?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/553/32553847.ipynb_qa_5" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +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 = "yes" +QUESTION = "Do the histograms of message lengths indicate that spam messages tend to have longer character counts than ham messages?" +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/0032_680_32680563_qa_2/instruction.md b/tasks/0032_680_32680563_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7034601c0340e306e6be5f3bed21526d173e8b2e --- /dev/null +++ b/tasks/0032_680_32680563_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of training samples for the author with the highest representation 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/0032_680_32680563_qa_2/task.toml b/tasks/0032_680_32680563_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b745949c2efbe86f2ae3bd2a32cb02285e12ef97 --- /dev/null +++ b/tasks/0032_680_32680563_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0032_680_32680563_qa_2" +description = "What is the total number of training samples for the author with the highest representation in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/680/32680563.ipynb_qa_2" +kaggle_dataset_name = "lyuyanhan/spookyauthordata" +gold_answer = "7900" +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 = "lyuyanhan__spookyauthordata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "lyuyanhan/spookyauthordata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7900" +QUESTION = "What is the total number of training samples for the author with the highest representation 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/0032_769_32769596_qa_1/instruction.md b/tasks/0032_769_32769596_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..92b936de6369114ae55280ff4352397f473b3d1d --- /dev/null +++ b/tasks/0032_769_32769596_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: +What is the highest classification accuracy achieved across different k values in the kNN model using 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/0032_769_32769596_qa_1/task.toml b/tasks/0032_769_32769596_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8c8e2c0b60922e509552eaa0f5c842ec2cb2dbd3 --- /dev/null +++ b/tasks/0032_769_32769596_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0032_769_32769596_qa_1" +description = "What is the highest classification accuracy achieved across different k values in the kNN model using the breast cancer dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/769/32769596.ipynb_qa_1" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.9649" +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 = "0.9649" +QUESTION = "What is the highest classification accuracy achieved across different k values in the kNN model using the breast cancer 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/0032_867_32867580_qa_1/instruction.md b/tasks/0032_867_32867580_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..33ff01f242a2cd97ba2424f5f334be731e1d7cd3 --- /dev/null +++ b/tasks/0032_867_32867580_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: +What is the skewness of the 'children' variable after applying the log transformation? + +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_867_32867580_qa_1/task.toml b/tasks/0032_867_32867580_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..47596a8b45290f2b5f305516d7a3072c01e92244 --- /dev/null +++ b/tasks/0032_867_32867580_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0032_867_32867580_qa_1" +description = "What is the skewness of the 'children' variable after applying the log transformation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/867/32867580.ipynb_qa_1" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "0.264" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.264" +QUESTION = "What is the skewness of the 'children' variable after applying the log transformation?" +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/0033_057_33057679_qa_1/instruction.md b/tasks/0033_057_33057679_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5712a5be64812419c09afad8aac82c7a170607f2 --- /dev/null +++ b/tasks/0033_057_33057679_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the original dataset represents individuals diagnosed with diabetes before any preprocessing steps? + +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/0033_057_33057679_qa_1/task.toml b/tasks/0033_057_33057679_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..79826af77cf5b77d9538860c9e6ec3a77cf6b287 --- /dev/null +++ b/tasks/0033_057_33057679_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0033_057_33057679_qa_1" +description = "What percentage of the original dataset represents individuals diagnosed with diabetes before any preprocessing steps?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/057/33057679.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "34.9" +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__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 = "34.9" +QUESTION = "What percentage of the original dataset represents individuals diagnosed with diabetes before any preprocessing steps?" +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/0033_273_33273125_qa_5/instruction.md b/tasks/0033_273_33273125_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6fb093f726887fbfe6a94a08fc96e9c068fea195 --- /dev/null +++ b/tasks/0033_273_33273125_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 range (maximum minus minimum) of density values in the entire 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/0033_273_33273125_qa_5/task.toml b/tasks/0033_273_33273125_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e567ccc6bffd3439a7db4c75dd2fe863edd3e67f --- /dev/null +++ b/tasks/0033_273_33273125_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0033_273_33273125_qa_5" +description = "What is the range (maximum minus minimum) of density values in the entire dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/273/33273125.ipynb_qa_5" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "0.01362" +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 = "0.01362" +QUESTION = "What is the range (maximum minus minimum) of density values in the entire 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/0033_423_33423582_qa_4/instruction.md b/tasks/0033_423_33423582_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c8d525163e6c61f4a128781a0c0a875fabe3c06b --- /dev/null +++ b/tasks/0033_423_33423582_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): +- movies_metadata.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average rating (C) across all movies in the dataset before applying the weighted rating formula? + +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/0033_423_33423582_qa_4/task.toml b/tasks/0033_423_33423582_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..df5d11930a9afb91c382ffa2ac5267c4aa2b2c7c --- /dev/null +++ b/tasks/0033_423_33423582_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0033_423_33423582_qa_4" +description = "What is the average rating (C) across all movies in the dataset before applying the weighted rating formula?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/423/33423582.ipynb_qa_4" +kaggle_dataset_name = "rounakbanik/the-movies-dataset" +gold_answer = "5.618207215133889" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "rounakbanik__the-movies-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rounakbanik/the-movies-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5.618207215133889" +QUESTION = "What is the average rating (C) across all movies in the dataset before applying the weighted rating formula?" +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/0033_684_33684962_qa_2/instruction.md b/tasks/0033_684_33684962_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..63cbca43018c72fa30f332aa4885cf596ac88427 --- /dev/null +++ b/tasks/0033_684_33684962_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): +- glass.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 cross-validation accuracy scores for the Random Forest model when using 100 estimators? + +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/0033_684_33684962_qa_2/task.toml b/tasks/0033_684_33684962_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9f3033a8d5e94272c8dc73c671a8a225ec875e1d --- /dev/null +++ b/tasks/0033_684_33684962_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0033_684_33684962_qa_2" +description = "What is the standard deviation of the cross-validation accuracy scores for the Random Forest model when using 100 estimators?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/684/33684962.ipynb_qa_2" +kaggle_dataset_name = "uciml/glass" +gold_answer = "0.0939" +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__glass" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/glass" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.0939" +QUESTION = "What is the standard deviation of the cross-validation accuracy scores for the Random Forest model when using 100 estimators?" +REWARD_MODE = "flexible" +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/0033_684_33684962_qa_5/instruction.md b/tasks/0033_684_33684962_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f94500a6f69a2a0f6674eedf34c29d5e16e71238 --- /dev/null +++ b/tasks/0033_684_33684962_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): +- glass.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which classification algorithm demonstrated the lowest test accuracy on the Glass dataset after all preprocessing steps? + +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/0033_684_33684962_qa_5/task.toml b/tasks/0033_684_33684962_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..987387606e21d467ef1eab45fff75b93d197a37b --- /dev/null +++ b/tasks/0033_684_33684962_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0033_684_33684962_qa_5" +description = "Which classification algorithm demonstrated the lowest test accuracy on the Glass dataset after all preprocessing steps?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/684/33684962.ipynb_qa_5" +kaggle_dataset_name = "uciml/glass" +gold_answer = "Naive Bayes" +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 = "uciml__glass" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/glass" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Naive Bayes" +QUESTION = "Which classification algorithm demonstrated the lowest test accuracy on the Glass dataset after all preprocessing steps?" +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/0033_697_33697266_qa_2/instruction.md b/tasks/0033_697_33697266_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0f1bf138adb4335b22b59a69a3ea79cdd8724d30 --- /dev/null +++ b/tasks/0033_697_33697266_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): +- indian_liver_patient.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which gender has the highest absolute count of liver disease cases 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/0033_697_33697266_qa_2/task.toml b/tasks/0033_697_33697266_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8d23d7278a977d626196ed6edbb5d01da51232ba --- /dev/null +++ b/tasks/0033_697_33697266_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0033_697_33697266_qa_2" +description = "Which gender has the highest absolute count of liver disease cases in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/697/33697266.ipynb_qa_2" +kaggle_dataset_name = "uciml/indian-liver-patient-records" +gold_answer = "Male" +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__indian-liver-patient-records" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/indian-liver-patient-records" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Male" +QUESTION = "Which gender has the highest absolute count of liver disease cases 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/0033_726_33726120_qa_4/instruction.md b/tasks/0033_726_33726120_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1ef76f65a9c63c0ccaee3a3a64ab8827c27cc7cc --- /dev/null +++ b/tasks/0033_726_33726120_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the absolute difference between the maximum carat value and the mean carat value in the cleaned diamonds 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/0033_726_33726120_qa_4/task.toml b/tasks/0033_726_33726120_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ff62cb89c2f6a8be598f6f8fe70f3e0c65d109ff --- /dev/null +++ b/tasks/0033_726_33726120_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0033_726_33726120_qa_4" +description = "What is the absolute difference between the maximum carat value and the mean carat value in the cleaned diamonds dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/726/33726120.ipynb_qa_4" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "4.21" +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4.21" +QUESTION = "What is the absolute difference between the maximum carat value and the mean carat value in the cleaned diamonds 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/0033_963_33963401_qa_1/instruction.md b/tasks/0033_963_33963401_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..60d03536b5f4047c8240f7747cca5b50dd274f4d --- /dev/null +++ b/tasks/0033_963_33963401_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): +- Churn_Modelling.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique numerical values were assigned to the "Geography" column after label encoding? + +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/0033_963_33963401_qa_1/task.toml b/tasks/0033_963_33963401_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bff36b46e8297cc6c351853504eca109786146de --- /dev/null +++ b/tasks/0033_963_33963401_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0033_963_33963401_qa_1" +description = "How many unique numerical values were assigned to the \"Geography\" column after label encoding?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/963/33963401.ipynb_qa_1" +kaggle_dataset_name = "filippoo/deep-learning-az-ann" +gold_answer = "3" +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 = "filippoo__deep-learning-az-ann" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "filippoo/deep-learning-az-ann" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many unique numerical values were assigned to the \"Geography\" column after label encoding?" +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/0033_988_33988731_qa_4/instruction.md b/tasks/0033_988_33988731_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..62f73ff10c557a4ffefe99fe0fd2ccd720bbd846 --- /dev/null +++ b/tasks/0033_988_33988731_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of individuals in the original dataset are diabetic (Outcome=1)? + +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/0033_988_33988731_qa_4/task.toml b/tasks/0033_988_33988731_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a339e9f9c3eca074c70026da7404717c69879e54 --- /dev/null +++ b/tasks/0033_988_33988731_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0033_988_33988731_qa_4" +description = "What percentage of individuals in the original dataset are diabetic (Outcome=1)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/988/33988731.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "34.9" +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__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 = "34.9" +QUESTION = "What percentage of individuals in the original dataset are diabetic (Outcome=1)?" +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/0034_339_34339717_qa_3/instruction.md b/tasks/0034_339_34339717_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..030b2b9b3a187771c00023a36271f06c7e957257 --- /dev/null +++ b/tasks/0034_339_34339717_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: +What is the F1-score for malignant (M) class predictions in the logistic regression model's validation 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/0034_339_34339717_qa_3/task.toml b/tasks/0034_339_34339717_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8d4de3d27e2bbb5a3faed3d9a518bab4891b8a35 --- /dev/null +++ b/tasks/0034_339_34339717_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0034_339_34339717_qa_3" +description = "What is the F1-score for malignant (M) class predictions in the logistic regression model's validation set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/339/34339717.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.94" +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 = "0.94" +QUESTION = "What is the F1-score for malignant (M) class predictions in the logistic regression model's validation 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/0034_748_34748003_qa_1/instruction.md b/tasks/0034_748_34748003_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ac23a84a4a22a582071ea905396e27f196f5e015 --- /dev/null +++ b/tasks/0034_748_34748003_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): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which primary Pokémon type has the highest average Attack value according to the box plot 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/0034_748_34748003_qa_1/task.toml b/tasks/0034_748_34748003_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..969d772e55fa0a9fde764402693474796c9c0ab6 --- /dev/null +++ b/tasks/0034_748_34748003_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0034_748_34748003_qa_1" +description = "Which primary Pokémon type has the highest average Attack value according to the box plot analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/748/34748003.ipynb_qa_1" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "Dragon" +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 = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Dragon" +QUESTION = "Which primary Pokémon type has the highest average Attack value according to the box plot analysis?" +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/0034_773_34773515_qa_3/instruction.md b/tasks/0034_773_34773515_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e6fd3940f7ea600c3d610b391c4585d077519a93 --- /dev/null +++ b/tasks/0034_773_34773515_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: +How many wines in the dataset are priced above $1000? + +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/0034_773_34773515_qa_3/task.toml b/tasks/0034_773_34773515_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0ee22436b1d187fd43b89cd38b0d55feaad8242e --- /dev/null +++ b/tasks/0034_773_34773515_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0034_773_34773515_qa_3" +description = "How many wines in the dataset are priced above $1000?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/773/34773515.ipynb_qa_3" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "14" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "14" +QUESTION = "How many wines in the dataset are priced above $1000?" +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/0034_912_34912092_qa_5/instruction.md b/tasks/0034_912_34912092_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..646c309cb361c0e97a94e3f2f11073c5d7579542 --- /dev/null +++ b/tasks/0034_912_34912092_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): +- german_credit_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 credit purpose among applicants with "free" housing status? + +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/0034_912_34912092_qa_5/task.toml b/tasks/0034_912_34912092_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..98868dcf4259849dc29b164dc0780a7104c46c43 --- /dev/null +++ b/tasks/0034_912_34912092_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0034_912_34912092_qa_5" +description = "What is the most common credit purpose among applicants with \"free\" housing status?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/912/34912092.ipynb_qa_5" +kaggle_dataset_name = "uciml/german-credit" +gold_answer = "car" +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__german-credit" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/german-credit" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "car" +QUESTION = "What is the most common credit purpose among applicants with \"free\" housing status?" +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_121_35121535_qa_1/instruction.md b/tasks/0035_121_35121535_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cfc76fc0e1d6c3845f80570bfb05e5b836e662a0 --- /dev/null +++ b/tasks/0035_121_35121535_qa_1/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): +- Test.csv +- Train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which outlet has the highest average Item_Outlet_Sales 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/0035_121_35121535_qa_1/task.toml b/tasks/0035_121_35121535_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..29711413561a427253fdcd9beae1bd2c37cd79c6 --- /dev/null +++ b/tasks/0035_121_35121535_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0035_121_35121535_qa_1" +description = "Which outlet has the highest average Item_Outlet_Sales according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/121/35121535.ipynb_qa_1" +kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data" +gold_answer = "OUT027" +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 = "brijbhushannanda1979__bigmart-sales-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "OUT027" +QUESTION = "Which outlet has the highest average Item_Outlet_Sales according to 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/0035_336_35336797_qa_5/instruction.md b/tasks/0035_336_35336797_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bd731e268880100eee1bd9db933a5e611a679ace --- /dev/null +++ b/tasks/0035_336_35336797_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): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the coefficient value for OverallQual in the multiple linear regression model using OverallQual, GrLivArea, GarageCars, GarageArea, TotalBsmtSF, and 1stFlrSF as predictors? + +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_336_35336797_qa_5/task.toml b/tasks/0035_336_35336797_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..240a8a419ed90e605f1f79c6a7515dc3e11da9eb --- /dev/null +++ b/tasks/0035_336_35336797_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_336_35336797_qa_5" +description = "What is the coefficient value for OverallQual in the multiple linear regression model using OverallQual, GrLivArea, GarageCars, GarageArea, TotalBsmtSF, and 1stFlrSF as predictors?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/336/35336797.ipynb_qa_5" +kaggle_dataset_name = "lespin/house-prices-dataset" +gold_answer = "23997.0394" +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 = "lespin__house-prices-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "lespin/house-prices-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "23997.0394" +QUESTION = "What is the coefficient value for OverallQual in the multiple linear regression model using OverallQual, GrLivArea, GarageCars, GarageArea, TotalBsmtSF, and 1stFlrSF as predictors?" +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/0035_546_35546963_qa_4/instruction.md b/tasks/0035_546_35546963_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..79fac2a859cd72be56e8ee2a6044eb7ae74c822d --- /dev/null +++ b/tasks/0035_546_35546963_qa_4/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): +- new-york_9-24-2016_9-30-2017.csv +- los-angeles_9-24-2016_9-30-2017.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 observations in the final combined dataset after merging New York and Los Angeles pumpkin price 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/0035_546_35546963_qa_4/task.toml b/tasks/0035_546_35546963_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2cf01225a0a6bff7e476be40291ea6e2df230259 --- /dev/null +++ b/tasks/0035_546_35546963_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0035_546_35546963_qa_4" +description = "What is the total number of observations in the final combined dataset after merging New York and Los Angeles pumpkin price data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/546/35546963.ipynb_qa_4" +kaggle_dataset_name = "usda/a-year-of-pumpkin-prices" +gold_answer = "174" +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 = "usda__a-year-of-pumpkin-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "usda/a-year-of-pumpkin-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "174" +QUESTION = "What is the total number of observations in the final combined dataset after merging New York and Los Angeles pumpkin price 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] diff --git a/tasks/0035_609_35609748_qa_1/instruction.md b/tasks/0035_609_35609748_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3c420f1577c393905eb1db5b637cb6a393e6d893 --- /dev/null +++ b/tasks/0035_609_35609748_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): +- auto-mpg.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many cars in the dataset have missing values in the horsepower column after data cleaning? + +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_609_35609748_qa_1/task.toml b/tasks/0035_609_35609748_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5ce5e5fb130a8962ccc71bde982960c57415b355 --- /dev/null +++ b/tasks/0035_609_35609748_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_609_35609748_qa_1" +description = "How many cars in the dataset have missing values in the horsepower column after data cleaning?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/609/35609748.ipynb_qa_1" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "6" +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__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many cars in the dataset have missing values in the horsepower column after data cleaning?" +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/0035_745_35745803_qa_1/instruction.md b/tasks/0035_745_35745803_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6e96fd1cc13db73ca041317f979e0dd3b927f282 --- /dev/null +++ b/tasks/0035_745_35745803_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 highest correlation coefficient between log_price and any other feature 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/0035_745_35745803_qa_1/task.toml b/tasks/0035_745_35745803_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0b835d9e03ffb3adc79888d013c498d73fb29f26 --- /dev/null +++ b/tasks/0035_745_35745803_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0035_745_35745803_qa_1" +description = "What is the highest correlation coefficient between log_price and any other feature in the cleaned dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/745/35745803.ipynb_qa_1" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "0.69" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.69" +QUESTION = "What is the highest correlation coefficient between log_price and any other feature 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/0035_921_35921172_qa_4/instruction.md b/tasks/0035_921_35921172_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..db2b7345ed2e01567ae3be50ef2d3cd95543a151 --- /dev/null +++ b/tasks/0035_921_35921172_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): +- inaug_speeches.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest Dale-Chall readability score recorded for any inaugural address 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/0035_921_35921172_qa_4/task.toml b/tasks/0035_921_35921172_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d2ac9ddf2fbc5c521225dd38c435abf1d4a71473 --- /dev/null +++ b/tasks/0035_921_35921172_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0035_921_35921172_qa_4" +description = "What is the highest Dale-Chall readability score recorded for any inaugural address in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/921/35921172.ipynb_qa_4" +kaggle_dataset_name = "adhok93/presidentialaddress" +gold_answer = "11.73" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "adhok93__presidentialaddress" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "adhok93/presidentialaddress" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11.73" +QUESTION = "What is the highest Dale-Chall readability score recorded for any inaugural address in the dataset?" +REWARD_MODE = "flexible" +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/0036_305_36305200_qa_3/instruction.md b/tasks/0036_305_36305200_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..eb5a1a0682f283a2a72501deb1633126d31a1e0c --- /dev/null +++ b/tasks/0036_305_36305200_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the cross-validation accuracy of the tuned Random Forest model using GridSearchCV parameters? + +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/0036_305_36305200_qa_3/task.toml b/tasks/0036_305_36305200_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a755abbe08180b5321761027281d4558639f9b27 --- /dev/null +++ b/tasks/0036_305_36305200_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0036_305_36305200_qa_3" +description = "What is the cross-validation accuracy of the tuned Random Forest model using GridSearchCV parameters?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/305/36305200.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "80.15" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "80.15" +QUESTION = "What is the cross-validation accuracy of the tuned Random Forest model using GridSearchCV parameters?" +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/0036_436_36436182_qa_5/instruction.md b/tasks/0036_436_36436182_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..46e0290b8c21a8d2cf246e193a163d99fa8906ad --- /dev/null +++ b/tasks/0036_436_36436182_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): +- auto-mpg.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 'horsepower' column before the KNN imputation 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/0036_436_36436182_qa_5/task.toml b/tasks/0036_436_36436182_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d20fd573732be29a4347b731fd23a477c6a9f6c2 --- /dev/null +++ b/tasks/0036_436_36436182_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0036_436_36436182_qa_5" +description = "How many missing values were present in the 'horsepower' column before the KNN imputation was applied?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/436/36436182.ipynb_qa_5" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "6" +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__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many missing values were present in the 'horsepower' column before the KNN imputation was applied?" +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/0036_916_36916974_qa_1/instruction.md b/tasks/0036_916_36916974_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b63bfac6c66dd14fb1334de557fd90109a8817fd --- /dev/null +++ b/tasks/0036_916_36916974_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: +What is the F1 score achieved by the XGBoost model using the specified beta parameter (β=0.5)? + +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/0036_916_36916974_qa_1/task.toml b/tasks/0036_916_36916974_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e2430b6df6a3cfe89bd45676b06e8f36d2cad208 --- /dev/null +++ b/tasks/0036_916_36916974_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0036_916_36916974_qa_1" +description = "What is the F1 score achieved by the XGBoost model using the specified beta parameter (β=0.5)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/916/36916974.ipynb_qa_1" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "1.0" +reward_mode_initial = "numeric" +package_tier = 2 +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 = "1.0" +QUESTION = "What is the F1 score achieved by the XGBoost model using the specified beta parameter (β=0.5)?" +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/0036_927_36927955_qa_1/instruction.md b/tasks/0036_927_36927955_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e2515c07b37662e7ba59b1a86ae7a78805fc5f38 --- /dev/null +++ b/tasks/0036_927_36927955_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): +- kiva_loans.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total loan amount distributed in the Rwanda region 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/0036_927_36927955_qa_1/task.toml b/tasks/0036_927_36927955_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..09bbcd99d05426c196c913184d3e23aac6a80c81 --- /dev/null +++ b/tasks/0036_927_36927955_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0036_927_36927955_qa_1" +description = "What is the total loan amount distributed in the Rwanda region according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/927/36927955.ipynb_qa_1" +kaggle_dataset_name = "kiva/data-science-for-good-kiva-crowdfunding" +gold_answer = "16616750.0" +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 = "kiva__data-science-for-good-kiva-crowdfunding" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kiva/data-science-for-good-kiva-crowdfunding" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "16616750.0" +QUESTION = "What is the total loan amount distributed in the Rwanda region according to the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +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/0037_093_37093290_qa_1/instruction.md b/tasks/0037_093_37093290_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8873095d41f47ffd999f61f7da5ca9267eeffa58 --- /dev/null +++ b/tasks/0037_093_37093290_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset shows the strongest linear correlation with the diabetes outcome variable? + +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/0037_093_37093290_qa_1/task.toml b/tasks/0037_093_37093290_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..31cd0d1db7b1ff67187ad909b6ac279c591fcabd --- /dev/null +++ b/tasks/0037_093_37093290_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0037_093_37093290_qa_1" +description = "Which feature in the dataset shows the strongest linear correlation with the diabetes outcome variable?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/093/37093290.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +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__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 = "Which feature in the dataset shows the strongest linear correlation with the diabetes outcome variable?" +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/0037_173_37173260_qa_1/instruction.md b/tasks/0037_173_37173260_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3c81a25c4ca67deda19ae10a57e28088a43e91cb --- /dev/null +++ b/tasks/0037_173_37173260_qa_1/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): +- Airplane_Crashes_and_Fatalities_Since_1908.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which non-military operator has the highest number of crashes in the dataset, and what is the most common aircraft type associated with their crashes? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, operator first, exact names). + +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/0037_173_37173260_qa_1/task.toml b/tasks/0037_173_37173260_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..88c846ab6ea713d6e8f581755aa4f779e069b7bc --- /dev/null +++ b/tasks/0037_173_37173260_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0037_173_37173260_qa_1" +description = "Which non-military operator has the highest number of crashes in the dataset, and what is the most common aircraft type associated with their crashes?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/173/37173260.ipynb_qa_1" +kaggle_dataset_name = "saurograndi/airplane-crashes-since-1908" +gold_answer = "Aeroflot, Yakovlev YAK-40" +reward_mode_initial = "list" +package_tier = 0 +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 = "saurograndi__airplane-crashes-since-1908" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "saurograndi/airplane-crashes-since-1908" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Aeroflot, Yakovlev YAK-40" +QUESTION = "Which non-military operator has the highest number of crashes in the dataset, and what is the most common aircraft type associated with their crashes?" +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/0037_236_37236169_qa_4/instruction.md b/tasks/0037_236_37236169_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7898753fa6b0ed79641bfa94a3645ff5c7e6649f --- /dev/null +++ b/tasks/0037_236_37236169_qa_4/instruction.md @@ -0,0 +1,19 @@ +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): +- PercentagePeopleBelowPovertyLevel.csv +- PercentOver25CompletedHighSchool.csv +- MedianHouseholdIncome2015.csv +- PoliceKillingsUS.csv +- ShareRaceByCity.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 names and surnames combined in the police killings 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/0037_236_37236169_qa_4/task.toml b/tasks/0037_236_37236169_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0d42231ec48b6d938eefffe6adf797db1a97bdbe --- /dev/null +++ b/tasks/0037_236_37236169_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0037_236_37236169_qa_4" +description = "What is the total number of unique names and surnames combined in the police killings dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/236/37236169.ipynb_qa_4" +kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us" +gold_answer = "4972" +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 = "kwullum__fatal-police-shootings-in-the-us" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2646" +QUESTION = "What is the total number of unique names and surnames combined in the police killings 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/0038_165_38165504_qa_3/instruction.md b/tasks/0038_165_38165504_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..320d500d385b7e5deb5d65e37448a11aceaa7cdf --- /dev/null +++ b/tasks/0038_165_38165504_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): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the test accuracy achieved by the Artificial Neural Network (ANN) model after training? + +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_165_38165504_qa_3/task.toml b/tasks/0038_165_38165504_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8c68c563da11aac422503a8d8ef4d0fd95ab3d1d --- /dev/null +++ b/tasks/0038_165_38165504_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_165_38165504_qa_3" +description = "What is the test accuracy achieved by the Artificial Neural Network (ANN) model after training?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/165/38165504.ipynb_qa_3" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "0.9730861244019139" +reward_mode_initial = "numeric" +package_tier = 2 +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__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 = "0.9730861244019139" +QUESTION = "What is the test accuracy achieved by the Artificial Neural Network (ANN) model after training?" +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_280_38280511_qa_5/instruction.md b/tasks/0038_280_38280511_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bd90aa45cc98757d5847be3e1feb9e4c0442d445 --- /dev/null +++ b/tasks/0038_280_38280511_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is there a statistically significant relationship between geographic region and insurance charges 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/0038_280_38280511_qa_5/task.toml b/tasks/0038_280_38280511_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..781fe30758dbe3910522848109082e7ebe12b6ec --- /dev/null +++ b/tasks/0038_280_38280511_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0038_280_38280511_qa_5" +description = "Is there a statistically significant relationship between geographic region and insurance charges in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/280/38280511.ipynb_qa_5" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "no" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "no" +QUESTION = "Is there a statistically significant relationship between geographic region and insurance charges in the dataset?" +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/0038_325_38325022_qa_3/instruction.md b/tasks/0038_325_38325022_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e425c161209af3152b7cadb357dcb7cd174fb5b9 --- /dev/null +++ b/tasks/0038_325_38325022_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum value of North American (NA) sales recorded for any video game? + +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_325_38325022_qa_3/task.toml b/tasks/0038_325_38325022_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..76204341121111095d241dc655703ef213d39d79 --- /dev/null +++ b/tasks/0038_325_38325022_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0038_325_38325022_qa_3" +description = "What is the maximum value of North American (NA) sales recorded for any video game?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/325/38325022.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "41.49" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "41.49" +QUESTION = "What is the maximum value of North American (NA) sales recorded for any video game?" +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/0038_547_38547552_qa_3/instruction.md b/tasks/0038_547_38547552_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d4f3451d8b03b1d995800653e6e3cf08cdd3748d --- /dev/null +++ b/tasks/0038_547_38547552_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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between Monthly Income and Age according to the correlation matrix 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/0038_547_38547552_qa_3/task.toml b/tasks/0038_547_38547552_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a4e7a566f754abfe82961703ffc9d7b29bb49430 --- /dev/null +++ b/tasks/0038_547_38547552_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0038_547_38547552_qa_3" +description = "What is the correlation coefficient between Monthly Income and Age according to the correlation matrix analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/547/38547552.ipynb_qa_3" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "0.50" +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 = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.50" +QUESTION = "What is the correlation coefficient between Monthly Income and Age according to the correlation matrix 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/0038_547_38547552_qa_4/instruction.md b/tasks/0038_547_38547552_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e56d5779b3d8b028e46045dac966b54fc782e76c --- /dev/null +++ b/tasks/0038_547_38547552_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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which gender group has a higher attrition rate according to the normalized cross-tabulation 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/0038_547_38547552_qa_4/task.toml b/tasks/0038_547_38547552_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c18e28887ec41241de3bce28ce29f6951d351b3b --- /dev/null +++ b/tasks/0038_547_38547552_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0038_547_38547552_qa_4" +description = "Which gender group has a higher attrition rate according to the normalized cross-tabulation analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/547/38547552.ipynb_qa_4" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "Male" +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 = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Male" +QUESTION = "Which gender group has a higher attrition rate according to the normalized cross-tabulation analysis?" +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/0038_570_38570610_qa_3/instruction.md b/tasks/0038_570_38570610_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3b97bf6df73db5d269d53e0255c8df59d7b07c33 --- /dev/null +++ b/tasks/0038_570_38570610_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which pair of features in the Iris dataset shows the highest positive correlation according to the correlation matrix? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact column names. + +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_570_38570610_qa_3/task.toml b/tasks/0038_570_38570610_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ec005882d910ac3f197554178347896f4955a778 --- /dev/null +++ b/tasks/0038_570_38570610_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0038_570_38570610_qa_3" +description = "Which pair of features in the Iris dataset shows the highest positive correlation according to the correlation matrix?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/570/38570610.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalLengthCm, PetalWidthCm" +reward_mode_initial = "list" +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 = "PetalLengthCm, PetalWidthCm" +QUESTION = "Which pair of features in the Iris dataset shows the highest positive correlation according to the correlation matrix?" +REWARD_MODE = "list_csv" +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/0038_606_38606903_qa_2/instruction.md b/tasks/0038_606_38606903_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d92d97f8869ca63cc8854c4fb8d5ae36f7c54166 --- /dev/null +++ b/tasks/0038_606_38606903_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: +How many video game entries are present in the dataset after removing 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/0038_606_38606903_qa_2/task.toml b/tasks/0038_606_38606903_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4a9475d7a89cd0cbe3d981edbea77dbdce1f7c53 --- /dev/null +++ b/tasks/0038_606_38606903_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0038_606_38606903_qa_2" +description = "How many video game entries are present in the dataset after removing missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/606/38606903.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "16291" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "16291" +QUESTION = "How many video game entries are present in the dataset after removing missing values?" +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/0038_688_38688219_qa_1/instruction.md b/tasks/0038_688_38688219_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1f0ce3f2dcfd5500b2aa93754e29e1ea561a98f8 --- /dev/null +++ b/tasks/0038_688_38688219_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 had the highest chi-square importance score in the feature selection 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/0038_688_38688219_qa_1/task.toml b/tasks/0038_688_38688219_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cdd7e83cc1f0fbc1ce7922ac6843b28a485d0c35 --- /dev/null +++ b/tasks/0038_688_38688219_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0038_688_38688219_qa_1" +description = "Which feature had the highest chi-square importance score in the feature selection process?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/688/38688219.ipynb_qa_1" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "gill-color" +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 = "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 had the highest chi-square importance score in the feature selection process?" +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/0038_708_38708794_qa_3/instruction.md b/tasks/0038_708_38708794_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..923b6e4842395be4556e7114b5abbe599792285f --- /dev/null +++ b/tasks/0038_708_38708794_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: +How many instances of missing values were present in the SkinThickness column before data imputation? + +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_708_38708794_qa_3/task.toml b/tasks/0038_708_38708794_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8b789b7484ed5e8b1016ed60d7563197b939baf8 --- /dev/null +++ b/tasks/0038_708_38708794_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0038_708_38708794_qa_3" +description = "How many instances of missing values were present in the SkinThickness column before data imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/708/38708794.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "227" +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 = "227" +QUESTION = "How many instances of missing values were present in the SkinThickness column before data imputation?" +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/0038_821_38821925_qa_1/instruction.md b/tasks/0038_821_38821925_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..32a0994ddbcd89bf34807d5c9ebd4ccd14e8d4f1 --- /dev/null +++ b/tasks/0038_821_38821925_qa_1/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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which features have the strongest correlation (absolute value ≥ 0.2) with wine quality in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact feature names. + +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_821_38821925_qa_1/task.toml b/tasks/0038_821_38821925_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c5cb4431a880604ec23500c66a33b53e9efdd04e --- /dev/null +++ b/tasks/0038_821_38821925_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_821_38821925_qa_1" +description = "Which features have the strongest correlation (absolute value ≥ 0.2) with wine quality in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/821/38821925.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "alcohol, sulphates, citric acid, volatile acidity" +reward_mode_initial = "list" +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__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 = "alcohol, sulphates, citric acid, volatile acidity" +QUESTION = "Which features have the strongest correlation (absolute value ≥ 0.2) with wine quality in the dataset?" +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/0038_884_38884588_qa_5/instruction.md b/tasks/0038_884_38884588_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7680bd45a9dd506e989711e1c9ca3d1c06bed8c2 --- /dev/null +++ b/tasks/0038_884_38884588_qa_5/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): +- student-mat.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which three numerical values are explicitly missing from the final grade (G3) categories in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the three missing values in ascending 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/0038_884_38884588_qa_5/task.toml b/tasks/0038_884_38884588_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..067460f906c1b07ec1a6a33f08966dcd076baf8f --- /dev/null +++ b/tasks/0038_884_38884588_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_884_38884588_qa_5" +description = "Which three numerical values are explicitly missing from the final grade (G3) categories in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/884/38884588.ipynb_qa_5" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "1, 2, 3" +reward_mode_initial = "list" +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__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1, 2, 3" +QUESTION = "Which three numerical values are explicitly missing from the final grade (G3) categories in the dataset?" +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/0038_970_38970193_qa_5/instruction.md b/tasks/0038_970_38970193_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2307832488c6a6d3c69aca4c25e1522e8a3df2e1 --- /dev/null +++ b/tasks/0038_970_38970193_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: +Which video game genre has the highest total sales in the Japanese market? + +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_970_38970193_qa_5/task.toml b/tasks/0038_970_38970193_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9b0be682e2d64f013c64917c800bef5683c28291 --- /dev/null +++ b/tasks/0038_970_38970193_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_970_38970193_qa_5" +description = "Which video game genre has the highest total sales in the Japanese market?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/970/38970193.ipynb_qa_5" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Role-Playing" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Role-Playing" +QUESTION = "Which video game genre has the highest total sales in the Japanese market?" +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/0039_234_39234687_qa_2/instruction.md b/tasks/0039_234_39234687_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..697133e83619f17e799a5d6ba8c0071aaf2ae9b6 --- /dev/null +++ b/tasks/0039_234_39234687_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): +- student-mat.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 two variables 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/0039_234_39234687_qa_2/task.toml b/tasks/0039_234_39234687_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..63acdd1898ed34ef62a086ecc98d9ef05497ffb5 --- /dev/null +++ b/tasks/0039_234_39234687_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_234_39234687_qa_2" +description = "What is the highest correlation coefficient between any two variables in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/234/39234687.ipynb_qa_2" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "0.904868" +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__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.904868" +QUESTION = "What is the highest correlation coefficient between any two variables 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/0039_370_39370613_qa_3/instruction.md b/tasks/0039_370_39370613_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..963cb7f6ba3ec8bd8188ade30129d7e198b7202c --- /dev/null +++ b/tasks/0039_370_39370613_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): +- german_credit_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the skewness value of the "Credit amount" column before applying any transformation? + +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/0039_370_39370613_qa_3/task.toml b/tasks/0039_370_39370613_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d9a9d7f0951528cf7baf3dd81ed8fa71280adb9a --- /dev/null +++ b/tasks/0039_370_39370613_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_370_39370613_qa_3" +description = "What was the skewness value of the \"Credit amount\" column before applying any transformation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/370/39370613.ipynb_qa_3" +kaggle_dataset_name = "uciml/german-credit" +gold_answer = "1.9496276798326209" +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__german-credit" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/german-credit" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.9496276798326209" +QUESTION = "What was the skewness value of the \"Credit amount\" column before applying any transformation?" +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/0039_470_39470080_qa_2/instruction.md b/tasks/0039_470_39470080_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e8c7a4c9b5f94e8f119c06611100929552e5387a --- /dev/null +++ b/tasks/0039_470_39470080_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): +- pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average base total statistic across all Pokémon 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/0039_470_39470080_qa_2/task.toml b/tasks/0039_470_39470080_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..84d8375f5863ebe8b9cbf6e425070ad17f81f1f9 --- /dev/null +++ b/tasks/0039_470_39470080_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_470_39470080_qa_2" +description = "What is the average base total statistic across all Pokémon in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/470/39470080.ipynb_qa_2" +kaggle_dataset_name = "rounakbanik/pokemon" +gold_answer = "428.38" +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 = "rounakbanik__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rounakbanik/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "428.38" +QUESTION = "What is the average base total statistic across all Pokémon 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/0039_512_39512601_qa_2/instruction.md b/tasks/0039_512_39512601_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d27e329fd32b1e4ac7bf79b0acf160eed45126f9 --- /dev/null +++ b/tasks/0039_512_39512601_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): +- Salary_Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which error metric has the highest value in the model evaluation? + +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/0039_512_39512601_qa_2/task.toml b/tasks/0039_512_39512601_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7418e385af53cbf7a173656f06efb10eabdce904 --- /dev/null +++ b/tasks/0039_512_39512601_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_512_39512601_qa_2" +description = "Which error metric has the highest value in the model evaluation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/512/39512601.ipynb_qa_2" +kaggle_dataset_name = "karthickveerakumar/salary-data-simple-linear-regression" +gold_answer = "Mean Squared Error" +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 = "karthickveerakumar__salary-data-simple-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "karthickveerakumar/salary-data-simple-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Mean Squared Error" +QUESTION = "Which error metric has the highest value in the model evaluation?" +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/0039_741_39741233_qa_5/instruction.md b/tasks/0039_741_39741233_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fe6af148c64a66595defd03e59026049a9e11c4c --- /dev/null +++ b/tasks/0039_741_39741233_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): +- bank.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which education level has the highest median account balance 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/0039_741_39741233_qa_5/task.toml b/tasks/0039_741_39741233_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8d692173b6503b1d1081e6e027b6295e9f66fb05 --- /dev/null +++ b/tasks/0039_741_39741233_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0039_741_39741233_qa_5" +description = "Which education level has the highest median account balance according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/741/39741233.ipynb_qa_5" +kaggle_dataset_name = "janiobachmann/bank-marketing-dataset" +gold_answer = "unknown" +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 = "janiobachmann__bank-marketing-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "unknown" +QUESTION = "Which education level has the highest median account balance according to 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/0039_782_39782405_qa_2/instruction.md b/tasks/0039_782_39782405_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d1de01904969b434433c950403bf68dbd29abc23 --- /dev/null +++ b/tasks/0039_782_39782405_qa_2/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): +- sign_mnist_train.csv +- sign_mnist_test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the shape of the preprocessed training images dataset after normalization and reshaping? + +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/0039_782_39782405_qa_2/task.toml b/tasks/0039_782_39782405_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d2f1e52b27964b7eb33946e3bbe962a1241912b9 --- /dev/null +++ b/tasks/0039_782_39782405_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_782_39782405_qa_2" +description = "What is the shape of the preprocessed training images dataset after normalization and reshaping?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/782/39782405.ipynb_qa_2" +kaggle_dataset_name = "datamunge/sign-language-mnist" +gold_answer = "(27455, 28, 28, 1)" +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 = "datamunge__sign-language-mnist" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datamunge/sign-language-mnist" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "(27455, 28, 28, 1)" +QUESTION = "What is the shape of the preprocessed training images dataset after normalization and reshaping?" +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/0039_839_39839532_qa_1/instruction.md b/tasks/0039_839_39839532_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1df6bb3b343a6ce24e0a2724ca4a0b091dad9a4c --- /dev/null +++ b/tasks/0039_839_39839532_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the proportion of diabetic patients (Outcome=1) among individuals with Skin Thickness values greater than the dataset mean? + +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/0039_839_39839532_qa_1/task.toml b/tasks/0039_839_39839532_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fb14d68a4839558813eb758878864b150fba5d8f --- /dev/null +++ b/tasks/0039_839_39839532_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_839_39839532_qa_1" +description = "What is the proportion of diabetic patients (Outcome=1) among individuals with Skin Thickness values greater than the dataset mean?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/839/39839532.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0.3908" +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 = "0.3908" +QUESTION = "What is the proportion of diabetic patients (Outcome=1) among individuals with Skin Thickness values greater than the dataset mean?" +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/0039_873_39873778_qa_5/instruction.md b/tasks/0039_873_39873778_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..50d3aa5c879a0b833296609584de2f99373bc316 --- /dev/null +++ b/tasks/0039_873_39873778_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: +Which wine quality score has the highest number of false negatives in the test set predictions? + +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/0039_873_39873778_qa_5/task.toml b/tasks/0039_873_39873778_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dea9b438a08189fbd42dfbdb52d5b24f4ca2366a --- /dev/null +++ b/tasks/0039_873_39873778_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_873_39873778_qa_5" +description = "Which wine quality score has the highest number of false negatives in the test set predictions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/873/39873778.ipynb_qa_5" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "6" +reward_mode_initial = "numeric" +package_tier = 3 +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__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 = "Which wine quality score has the highest number of false negatives in the test set predictions?" +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/0039_908_39908824_qa_4/instruction.md b/tasks/0039_908_39908824_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..90b49333b14545a507b5451a54b69c0a3548bb4e --- /dev/null +++ b/tasks/0039_908_39908824_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): +- 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? + +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/0039_908_39908824_qa_4/task.toml b/tasks/0039_908_39908824_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..db2c9d636fb3815ecbef3a15f9790a3cb0e1bf56 --- /dev/null +++ b/tasks/0039_908_39908824_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_908_39908824_qa_4" +description = "What percentage of the dataset consists of spam messages?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/908/39908824.ipynb_qa_4" +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?" +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/0040_298_40298967_qa_5/instruction.md b/tasks/0040_298_40298967_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a3c444c80d444d69dc25402be84f2054aa441399 --- /dev/null +++ b/tasks/0040_298_40298967_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): +- insurance.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-squared) for the multiple linear regression model on the test 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_298_40298967_qa_5/task.toml b/tasks/0040_298_40298967_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dbccea39d2af63dc2d902cb28460013ef595aec3 --- /dev/null +++ b/tasks/0040_298_40298967_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0040_298_40298967_qa_5" +description = "What is the coefficient of determination (R-squared) for the multiple linear regression model on the test dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/298/40298967.ipynb_qa_5" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "0.7979" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.7979" +QUESTION = "What is the coefficient of determination (R-squared) for the multiple linear regression model on the test dataset?" +REWARD_MODE = "flexible" +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/0040_783_40783338_qa_3/instruction.md b/tasks/0040_783_40783338_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8966a431cb038a04bbd0bb94d2cbca2749e627f4 --- /dev/null +++ b/tasks/0040_783_40783338_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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which dataset, the initial test split or the external test dataset, results in a higher Mean Absolute Error (MAE) for the model predictions? + +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_783_40783338_qa_3/task.toml b/tasks/0040_783_40783338_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d1ad2a820d3f3c85164ce0a04c2d29651de5ec35 --- /dev/null +++ b/tasks/0040_783_40783338_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0040_783_40783338_qa_3" +description = "Which dataset, the initial test split or the external test dataset, results in a higher Mean Absolute Error (MAE) for the model predictions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/783/40783338.ipynb_qa_3" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "External test dataset" +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 = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "External test dataset" +QUESTION = "Which dataset, the initial test split or the external test dataset, results in a higher Mean Absolute Error (MAE) for the model predictions?" +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_916_40916847_qa_3/instruction.md b/tasks/0040_916_40916847_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cf37a90012a61c13d927dd08c8ec16357b8243bf --- /dev/null +++ b/tasks/0040_916_40916847_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent region in the dataset based on the value counts 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/0040_916_40916847_qa_3/task.toml b/tasks/0040_916_40916847_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f0d4c3cb05e7309da29a4707c705dcb774772953 --- /dev/null +++ b/tasks/0040_916_40916847_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_916_40916847_qa_3" +description = "What is the most frequent region in the dataset based on the value counts analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/916/40916847.ipynb_qa_3" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "southeast" +reward_mode_initial = "exact_short" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "southeast" +QUESTION = "What is the most frequent region in the dataset based on the value counts analysis?" +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/0041_015_41015677_qa_2/instruction.md b/tasks/0041_015_41015677_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..83598ca07d087faa757a30fe233df91f612f5dbf --- /dev/null +++ b/tasks/0041_015_41015677_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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which two input features have the strongest positive and negative correlations with wine quality (excluding the target itself)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the two exact feature names, in the order positive then negative. + +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_015_41015677_qa_2/task.toml b/tasks/0041_015_41015677_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..671dc1a7803052922c8a0e1949b589f4c70532cd --- /dev/null +++ b/tasks/0041_015_41015677_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_015_41015677_qa_2" +description = "Which two input features have the strongest positive and negative correlations with wine quality (excluding the target itself)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/015/41015677.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "Alcohol, volatile acidity" +reward_mode_initial = "list" +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__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 = "Alcohol, volatile acidity" +QUESTION = "Which two input features have the strongest positive and negative correlations with wine quality (excluding the target itself)?" +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/0041_172_41172395_qa_3/instruction.md b/tasks/0041_172_41172395_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3b7a025c8daf00575f538208c36d045cfcb1099e --- /dev/null +++ b/tasks/0041_172_41172395_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which sales region (NA, EU, JP, or Other) shows the strongest positive correlation with Global_Sales according to the dataset's 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/0041_172_41172395_qa_3/task.toml b/tasks/0041_172_41172395_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..07a7c9ad9b5853f8bc4ffe74455c416f8f6f42fe --- /dev/null +++ b/tasks/0041_172_41172395_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0041_172_41172395_qa_3" +description = "Which sales region (NA, EU, JP, or Other) shows the strongest positive correlation with Global_Sales according to the dataset's correlation matrix?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/172/41172395.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "NA" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "NA" +QUESTION = "Which sales region (NA, EU, JP, or Other) shows the strongest positive correlation with Global_Sales according to the dataset's 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/0041_214_41214331_qa_5/instruction.md b/tasks/0041_214_41214331_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..89d7ec6c5f3ceb22200cfd13807340d4b284302c --- /dev/null +++ b/tasks/0041_214_41214331_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 is the shortest message length recorded 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/0041_214_41214331_qa_5/task.toml b/tasks/0041_214_41214331_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..29a590e078c800f201cab21a551c61e62ef9c129 --- /dev/null +++ b/tasks/0041_214_41214331_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_214_41214331_qa_5" +description = "What is the shortest message length recorded in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/214/41214331.ipynb_qa_5" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "2" +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__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 = "2" +QUESTION = "What is the shortest message length recorded 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/0041_216_41216352_qa_3/instruction.md b/tasks/0041_216_41216352_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fe43248509432d7b41c241d6b36fb717ecab9946 --- /dev/null +++ b/tasks/0041_216_41216352_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which year within the dataset's range recorded the highest sales in the North American market? + +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_216_41216352_qa_3/task.toml b/tasks/0041_216_41216352_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9803cd786b8bd9e5c8b50ce39a980b571330cb32 --- /dev/null +++ b/tasks/0041_216_41216352_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_216_41216352_qa_3" +description = "Which year within the dataset's range recorded the highest sales in the North American market?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/216/41216352.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "2008" +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 = "2008" +QUESTION = "Which year within the dataset's range recorded the highest sales in the North American market?" +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/0041_321_41321221_qa_2/instruction.md b/tasks/0041_321_41321221_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dec27b64aabc012f0e1a1dae74589b140a9b5a87 --- /dev/null +++ b/tasks/0041_321_41321221_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which workclass category has the highest average hours per week worked 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/0041_321_41321221_qa_2/task.toml b/tasks/0041_321_41321221_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..723a93693523861da2183f2d1c0778aba1cea34b --- /dev/null +++ b/tasks/0041_321_41321221_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_321_41321221_qa_2" +description = "Which workclass category has the highest average hours per week worked according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/321/41321221.ipynb_qa_2" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "Self-emp-inc" +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 = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Self-emp-inc" +QUESTION = "Which workclass category has the highest average hours per week worked according to 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/0041_571_41571567_qa_4/instruction.md b/tasks/0041_571_41571567_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..53bdda2c5018b621a598b6f6be83a7b298d267ec --- /dev/null +++ b/tasks/0041_571_41571567_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which game in the top 3 of 2015 had the highest sales in Japan? + +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_571_41571567_qa_4/task.toml b/tasks/0041_571_41571567_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6a483372845fafc67564492103c1343771655c5b --- /dev/null +++ b/tasks/0041_571_41571567_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0041_571_41571567_qa_4" +description = "Which game in the top 3 of 2015 had the highest sales in Japan?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/571/41571567.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Call of Duty: Black Ops 3" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Call of Duty: Black Ops 3" +QUESTION = "Which game in the top 3 of 2015 had the highest sales in Japan?" +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/0041_712_41712543_qa_1/instruction.md b/tasks/0041_712_41712543_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ae61374bff6f0a4c57d3e58a84c2bb1c29a92521 --- /dev/null +++ b/tasks/0041_712_41712543_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): +- KAG_conversion_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which age group has the highest median Total_Conversion rate according to the dataset 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/0041_712_41712543_qa_1/task.toml b/tasks/0041_712_41712543_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7af1b7bd8311768676a5259c890107a7248d0b21 --- /dev/null +++ b/tasks/0041_712_41712543_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0041_712_41712543_qa_1" +description = "Which age group has the highest median Total_Conversion rate according to the dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/712/41712543.ipynb_qa_1" +kaggle_dataset_name = "loveall/clicks-conversion-tracking" +gold_answer = "30-34" +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 = "loveall__clicks-conversion-tracking" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "loveall/clicks-conversion-tracking" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "30-34" +QUESTION = "Which age group has the highest median Total_Conversion rate according to the dataset analysis?" +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/0041_818_41818748_qa_5/instruction.md b/tasks/0041_818_41818748_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c263d648b305a24217915b9b09ceb6ee5acf14df --- /dev/null +++ b/tasks/0041_818_41818748_qa_5/instruction.md @@ -0,0 +1,18 @@ +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 +- Test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of total sales contributed by Supermarket Type1 outlets compared to other outlet types? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a percentage (e.g. 95.5), not a fraction. + +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_818_41818748_qa_5/task.toml b/tasks/0041_818_41818748_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..27bd2a28c2f6cb549ba30d7a36279d6d63b3144a --- /dev/null +++ b/tasks/0041_818_41818748_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0041_818_41818748_qa_5" +description = "What is the percentage of total sales contributed by Supermarket Type1 outlets compared to other outlet types?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/818/41818748.ipynb_qa_5" +kaggle_dataset_name = "devashish0507/big-mart-sales-prediction" +gold_answer = "48.2%" +reward_mode_initial = "flexible" +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 = "devashish0507__big-mart-sales-prediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "devashish0507/big-mart-sales-prediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "69.48%" +QUESTION = "What is the percentage of total sales contributed by Supermarket Type1 outlets compared to other outlet types?" +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/0042_049_42049242_qa_1/instruction.md b/tasks/0042_049_42049242_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2eef276f031ff89a4cc96b4f5843512ecd46387c --- /dev/null +++ b/tasks/0042_049_42049242_qa_1/instruction.md @@ -0,0 +1,18 @@ +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 +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which passenger class (Pclass) had the highest survival rate based on the grouped analysis, and what was the survival rate percentage? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, class first, percentage with two decimals). + +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_049_42049242_qa_1/task.toml b/tasks/0042_049_42049242_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4e6727408cfa9cf7aac0a2dbd1dce28650455ee1 --- /dev/null +++ b/tasks/0042_049_42049242_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0042_049_42049242_qa_1" +description = "Which passenger class (Pclass) had the highest survival rate based on the grouped analysis, and what was the survival rate percentage?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/049/42049242.ipynb_qa_1" +kaggle_dataset_name = "sweetyparmar1/titanic" +gold_answer = "1, 62.96%" +reward_mode_initial = "list" +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 = "sweetyparmar1__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sweetyparmar1/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1, 62.96%" +QUESTION = "Which passenger class (Pclass) had the highest survival rate based on the grouped analysis, and what was the survival rate percentage?" +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/0042_528_42528802_qa_3/instruction.md b/tasks/0042_528_42528802_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3cc4056eeb26216049bb4a1135bc55e698455086 --- /dev/null +++ b/tasks/0042_528_42528802_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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the correlation between MonthlyIncome and JobLevel in the dataset 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/0042_528_42528802_qa_3/task.toml b/tasks/0042_528_42528802_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fbcee753c166e1a0cec2c1026bb8e776b1e3e9a7 --- /dev/null +++ b/tasks/0042_528_42528802_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0042_528_42528802_qa_3" +description = "Is the correlation between MonthlyIncome and JobLevel in the dataset statistically significant?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/528/42528802.ipynb_qa_3" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 2 +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 = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the correlation between MonthlyIncome and JobLevel in the dataset 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/0042_773_42773926_qa_3/instruction.md b/tasks/0042_773_42773926_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..56b2f8929a6faebee41409aa28d720e56ff9b3dd --- /dev/null +++ b/tasks/0042_773_42773926_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): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which month (numeric value) had the highest average house price based on the sales 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/0042_773_42773926_qa_3/task.toml b/tasks/0042_773_42773926_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..efebc205a3db3ca12ff3719dfcbefd23ca72e28f --- /dev/null +++ b/tasks/0042_773_42773926_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0042_773_42773926_qa_3" +description = "Which month (numeric value) had the highest average house price based on the sales data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/773/42773926.ipynb_qa_3" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "4" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "Which month (numeric value) had the highest average house price based on the sales 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] diff --git a/tasks/0042_991_42991381_qa_5/instruction.md b/tasks/0042_991_42991381_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..75e0737cc28b2a0cc008dd79b2dc1171eb86ab0f --- /dev/null +++ b/tasks/0042_991_42991381_qa_5/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between Annual_Premium and Vintage based on the heatmap 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/0042_991_42991381_qa_5/task.toml b/tasks/0042_991_42991381_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e26d574de333de8c5bb1332bb0337a8a2af13c92 --- /dev/null +++ b/tasks/0042_991_42991381_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0042_991_42991381_qa_5" +description = "What is the correlation coefficient between Annual_Premium and Vintage based on the heatmap analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/991/42991381.ipynb_qa_5" +kaggle_dataset_name = "apollo2506/flowers-recognition-dataset" +gold_answer = "-0.01" +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 = "apollo2506__flowers-recognition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "apollo2506/flowers-recognition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "-0.01" +QUESTION = "What is the correlation coefficient between Annual_Premium and Vintage based on the heatmap 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/0043_069_43069626_qa_4/instruction.md b/tasks/0043_069_43069626_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..731e2866c908007f568646885685a39104a14810 --- /dev/null +++ b/tasks/0043_069_43069626_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): +- jena_climate_2009_2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the 75th percentile of temperature (T (degC)) in the training 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/0043_069_43069626_qa_4/task.toml b/tasks/0043_069_43069626_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5d6b1a820f5aaab88f99b41fb9e899509b67c5c9 --- /dev/null +++ b/tasks/0043_069_43069626_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0043_069_43069626_qa_4" +description = "What is the 75th percentile of temperature (T (degC)) in the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/069/43069626.ipynb_qa_4" +kaggle_dataset_name = "pankrzysiu/weather-archive-jena" +gold_answer = "15.47" +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 = "pankrzysiu__weather-archive-jena" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pankrzysiu/weather-archive-jena" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "15.47" +QUESTION = "What is the 75th percentile of temperature (T (degC)) in the training 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/0043_419_43419580_qa_2/instruction.md b/tasks/0043_419_43419580_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fce27b863375c5e3ba665b310aa7c9783b7acf88 --- /dev/null +++ b/tasks/0043_419_43419580_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 percentage of wines in the dataset are classified as "good quality" (value = 1) based on the binary classification threshold? + +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/0043_419_43419580_qa_2/task.toml b/tasks/0043_419_43419580_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cb5c0923579f615e363ed941ed3d07e079bfa434 --- /dev/null +++ b/tasks/0043_419_43419580_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0043_419_43419580_qa_2" +description = "What percentage of wines in the dataset are classified as \"good quality\" (value = 1) based on the binary classification threshold?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/419/43419580.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "13.57" +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__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 = "13.57" +QUESTION = "What percentage of wines in the dataset are classified as \"good quality\" (value = 1) based on the binary classification threshold?" +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/0043_524_43524264_qa_1/instruction.md b/tasks/0043_524_43524264_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c53bfdc391e66cd8ca94c7d8ff55e967789a989c --- /dev/null +++ b/tasks/0043_524_43524264_qa_1/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which age group has the highest total purchase amount 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/0043_524_43524264_qa_1/task.toml b/tasks/0043_524_43524264_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c560914fa03eb11c105d429d714a0d7b6cfca456 --- /dev/null +++ b/tasks/0043_524_43524264_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0043_524_43524264_qa_1" +description = "Which age group has the highest total purchase amount in the training data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/524/43524264.ipynb_qa_1" +kaggle_dataset_name = "sdolezel/black-friday" +gold_answer = "26-35" +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 = "sdolezel__black-friday" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sdolezel/black-friday" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "26-35" +QUESTION = "Which age group has the highest total purchase amount in the training data?" +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/0043_829_43829102_qa_2/instruction.md b/tasks/0043_829_43829102_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b176d9ee5749da7925789d106f3f80024700bd30 --- /dev/null +++ b/tasks/0043_829_43829102_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: +Which feature in the dataset has the highest positive correlation with the Survived column based on the heatmap visualization? + +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/0043_829_43829102_qa_2/task.toml b/tasks/0043_829_43829102_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..646ae42c669fa4acc732e446bb31f9ca98de19cb --- /dev/null +++ b/tasks/0043_829_43829102_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0043_829_43829102_qa_2" +description = "Which feature in the dataset has the highest positive correlation with the Survived column based on the heatmap visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/829/43829102.ipynb_qa_2" +kaggle_dataset_name = "heptapod/titanic" +gold_answer = "Sex" +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 = "heptapod__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "heptapod/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Sex" +QUESTION = "Which feature in the dataset has the highest positive correlation with the Survived column based on the heatmap visualization?" +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/0043_829_43829102_qa_5/instruction.md b/tasks/0043_829_43829102_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d0100d98fe1472649e78d4c751ff232b667e669b --- /dev/null +++ b/tasks/0043_829_43829102_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): +- train_and_test2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature exhibits the strongest negative correlation with the Survived column according to the correlation heatmap? + +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/0043_829_43829102_qa_5/task.toml b/tasks/0043_829_43829102_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7105edcda15f0137046a9135445a31faf43d26ea --- /dev/null +++ b/tasks/0043_829_43829102_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0043_829_43829102_qa_5" +description = "Which feature exhibits the strongest negative correlation with the Survived column according to the correlation heatmap?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/829/43829102.ipynb_qa_5" +kaggle_dataset_name = "heptapod/titanic" +gold_answer = "PassengerId" +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 = "heptapod__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "heptapod/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PassengerId" +QUESTION = "Which feature exhibits the strongest negative correlation with the Survived column according to the correlation heatmap?" +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/0044_193_44193489_qa_1/instruction.md b/tasks/0044_193_44193489_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0e04d0f8d5fc34eb96d051ebe2816a4107112a6d --- /dev/null +++ b/tasks/0044_193_44193489_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 skewness value of the price distribution in the original dataset before outlier removal? + +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/0044_193_44193489_qa_1/task.toml b/tasks/0044_193_44193489_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..da910492c315487ea7dc8b14ab15036419e212ab --- /dev/null +++ b/tasks/0044_193_44193489_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0044_193_44193489_qa_1" +description = "What is the skewness value of the price distribution in the original dataset before outlier removal?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0044/193/44193489.ipynb_qa_1" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "4.024069" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4.024069" +QUESTION = "What is the skewness value of the price distribution in the original dataset before outlier removal?" +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/0044_251_44251119_qa_3/instruction.md b/tasks/0044_251_44251119_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3ac54e72673c0bb71bd0406d56d55d140b3290f0 --- /dev/null +++ b/tasks/0044_251_44251119_qa_3/instruction.md @@ -0,0 +1,19 @@ +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): +- MedianHouseholdIncome2015.csv +- PercentagePeopleBelowPovertyLevel.csv +- PercentOver25CompletedHighSchool.csv +- ShareRaceByCity.csv +- PoliceKillingsUS.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 geographic areas represented in the poverty rate 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/0044_251_44251119_qa_3/task.toml b/tasks/0044_251_44251119_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fd444811984422dd01184936a497a929ec518e0b --- /dev/null +++ b/tasks/0044_251_44251119_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0044_251_44251119_qa_3" +description = "What is the total number of unique geographic areas represented in the poverty rate dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0044/251/44251119.ipynb_qa_3" +kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us" +gold_answer = "51" +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 = "kwullum__fatal-police-shootings-in-the-us" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "51" +QUESTION = "What is the total number of unique geographic areas represented in the poverty rate 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/0044_412_44412230_qa_1/instruction.md b/tasks/0044_412_44412230_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c2b9be328423ced65a6ecdebc2f3f7c9fec04c92 --- /dev/null +++ b/tasks/0044_412_44412230_qa_1/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): +- salaries-by-college-type.csv +- salaries-by-region.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average mid-career median salary for Engineering schools in the Northeastern region? + +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/0044_412_44412230_qa_1/task.toml b/tasks/0044_412_44412230_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b81c5e7f5b4a7792eb662c1d6f0210750be1aa2b --- /dev/null +++ b/tasks/0044_412_44412230_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0044_412_44412230_qa_1" +description = "What is the average mid-career median salary for Engineering schools in the Northeastern region?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0044/412/44412230.ipynb_qa_1" +kaggle_dataset_name = "wsj/college-salaries" +gold_answer = "108366" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "wsj__college-salaries" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wsj/college-salaries" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "108366" +QUESTION = "What is the average mid-career median salary for Engineering schools in the Northeastern region?" +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/0044_466_44466723_qa_4/instruction.md b/tasks/0044_466_44466723_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dc457e3ad32853afdc7f1dfe612721eea8b593df --- /dev/null +++ b/tasks/0044_466_44466723_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median sepal width 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/0044_466_44466723_qa_4/task.toml b/tasks/0044_466_44466723_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..40256e7ddccf0461e0e9783f10b45f777c1f7f99 --- /dev/null +++ b/tasks/0044_466_44466723_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0044_466_44466723_qa_4" +description = "What is the median sepal width in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0044/466/44466723.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "3.0" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3.0" +QUESTION = "What is the median sepal width 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/0045_136_45136493_qa_3/instruction.md b/tasks/0045_136_45136493_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..74d9eb2b1f738f6989ec933e901c28407ead098e --- /dev/null +++ b/tasks/0045_136_45136493_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which two species exhibit the most overlapping sepal measurements based on the scatter plot observations? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the two species names, in the order given. + +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_136_45136493_qa_3/task.toml b/tasks/0045_136_45136493_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f135a02efd80de77d226954d63cf97bcf2bd75fe --- /dev/null +++ b/tasks/0045_136_45136493_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0045_136_45136493_qa_3" +description = "Which two species exhibit the most overlapping sepal measurements based on the scatter plot observations?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/136/45136493.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-versicolor, Iris-virginica" +reward_mode_initial = "list" +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 = "Iris-versicolor, Iris-virginica" +QUESTION = "Which two species exhibit the most overlapping sepal measurements based on the scatter plot observations?" +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/0045_138_45138042_qa_4/instruction.md b/tasks/0045_138_45138042_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ea3950e7a8772da94f15a428929dfe67e7a40a6e --- /dev/null +++ b/tasks/0045_138_45138042_qa_4/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): +- tests.csv +- combats.csv +- pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common primary type ('Type 1') among all Pokémon 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_138_45138042_qa_4/task.toml b/tasks/0045_138_45138042_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8661ef8f2a4ec4d7035e8a9bad6e6e39a974fe2d --- /dev/null +++ b/tasks/0045_138_45138042_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0045_138_45138042_qa_4" +description = "What is the most common primary type ('Type 1') among all Pokémon in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/138/45138042.ipynb_qa_4" +kaggle_dataset_name = "terminus7/pokemon-challenge" +gold_answer = "Water" +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 = "terminus7__pokemon-challenge" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Water" +QUESTION = "What is the most common primary type ('Type 1') among all Pokémon 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/0045_409_45409591_qa_1/instruction.md b/tasks/0045_409_45409591_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b26fbb4cb71dc5f0c9a6438a9154c209536fed96 --- /dev/null +++ b/tasks/0045_409_45409591_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 column was dropped due to containing the highest proportion of missing 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/0045_409_45409591_qa_1/task.toml b/tasks/0045_409_45409591_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d8b1d830a4833e94462eec39c6ad66e0eee9f616 --- /dev/null +++ b/tasks/0045_409_45409591_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0045_409_45409591_qa_1" +description = "Which column was dropped due to containing the highest proportion of missing values in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/409/45409591.ipynb_qa_1" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "region_2" +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 = "region_2" +QUESTION = "Which column was dropped due to containing the highest proportion of missing values 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/0045_454_45454053_qa_3/instruction.md b/tasks/0045_454_45454053_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e9b2d35542626b85626fd4a590472342013feab8 --- /dev/null +++ b/tasks/0045_454_45454053_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 percentage of variance retained by using 50 principal components after one-hot encoding all categorical variables? + +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_454_45454053_qa_3/task.toml b/tasks/0045_454_45454053_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7e079eae8d070c54cc30456c3b2777806d4d84d6 --- /dev/null +++ b/tasks/0045_454_45454053_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0045_454_45454053_qa_3" +description = "What is the percentage of variance retained by using 50 principal components after one-hot encoding all categorical variables?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/454/45454053.ipynb_qa_3" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "98.1" +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 = "98.1" +QUESTION = "What is the percentage of variance retained by using 50 principal components after one-hot encoding all categorical variables?" +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_605_45605559_qa_1/instruction.md b/tasks/0045_605_45605559_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..07e14a5d70a864b6719840b4fd50dffd8a527ee8 --- /dev/null +++ b/tasks/0045_605_45605559_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 total number of samples remaining in the dataset after removing the 'Iris-virginica' class? + +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_605_45605559_qa_1/task.toml b/tasks/0045_605_45605559_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3c7bc0a112fcef4d77a8be5e9a860f01953e1eec --- /dev/null +++ b/tasks/0045_605_45605559_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0045_605_45605559_qa_1" +description = "What is the total number of samples remaining in the dataset after removing the 'Iris-virginica' class?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/605/45605559.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "100" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "100" +QUESTION = "What is the total number of samples remaining in the dataset after removing the 'Iris-virginica' class?" +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/0045_670_45670809_qa_3/instruction.md b/tasks/0045_670_45670809_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8f14bc4baccf742a06b0aad1cbac6af2b56a4a19 --- /dev/null +++ b/tasks/0045_670_45670809_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): +- phone_dataset .csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the number of unique phone models 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_670_45670809_qa_3/task.toml b/tasks/0045_670_45670809_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..99d632066e0ab5dfa9b4145742eb7de203d5d0ac --- /dev/null +++ b/tasks/0045_670_45670809_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0045_670_45670809_qa_3" +description = "What is the number of unique phone models in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/670/45670809.ipynb_qa_3" +kaggle_dataset_name = "arwinneil/gsmarena-phone-dataset" +gold_answer = "8273" +reward_mode_initial = "numeric" +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 = "arwinneil__gsmarena-phone-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arwinneil/gsmarena-phone-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "8273" +QUESTION = "What is the number of unique phone models 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/0045_821_45821165_qa_3/instruction.md b/tasks/0045_821_45821165_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a56bfd6a6d6b98036f355254978bb4f482f28e34 --- /dev/null +++ b/tasks/0045_821_45821165_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): +- 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 percentage of houses in the dataset that have a waterfront view? + +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_821_45821165_qa_3/task.toml b/tasks/0045_821_45821165_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..955e43905e16ba6ee872cc9fe7138768370287f0 --- /dev/null +++ b/tasks/0045_821_45821165_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0045_821_45821165_qa_3" +description = "What is the percentage of houses in the dataset that have a waterfront view?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/821/45821165.ipynb_qa_3" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "0.7541757209662947" +reward_mode_initial = "numeric" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.7541757209662947" +QUESTION = "What is the percentage of houses in the dataset that have a waterfront view?" +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/0045_874_45874370_qa_5/instruction.md b/tasks/0045_874_45874370_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..46c9f0c95329a26a568e4697059ae1ec84a6a9ef --- /dev/null +++ b/tasks/0045_874_45874370_qa_5/instruction.md @@ -0,0 +1,18 @@ +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): +- test.csv +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of mobile phones in price range 0 are 3G compatible according to the pie chart visualization? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a percentage (e.g. 95.5), not a fraction. + +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_874_45874370_qa_5/task.toml b/tasks/0045_874_45874370_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..631b6e78cc53d53ad2b0e0722206020c0ed9cc8a --- /dev/null +++ b/tasks/0045_874_45874370_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0045_874_45874370_qa_5" +description = "What percentage of mobile phones in price range 0 are 3G compatible according to the pie chart visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/874/45874370.ipynb_qa_5" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "98.5%" +reward_mode_initial = "flexible" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "74.6%" +QUESTION = "What percentage of mobile phones in price range 0 are 3G compatible according to the pie chart visualization?" +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/0045_969_45969290_qa_1/instruction.md b/tasks/0045_969_45969290_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..04fb6c55ce0c81909c2e281a24ed781cf04e5e3b --- /dev/null +++ b/tasks/0045_969_45969290_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): +- menu.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique menu item categories are present in the dataset after label encoding? + +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_969_45969290_qa_1/task.toml b/tasks/0045_969_45969290_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..06c16e55a46a5ebad3ece9ed2b5e86a9625bbc66 --- /dev/null +++ b/tasks/0045_969_45969290_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0045_969_45969290_qa_1" +description = "How many unique menu item categories are present in the dataset after label encoding?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/969/45969290.ipynb_qa_1" +kaggle_dataset_name = "mcdonalds/nutrition-facts" +gold_answer = "9" +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 = "mcdonalds__nutrition-facts" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mcdonalds/nutrition-facts" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "9" +QUESTION = "How many unique menu item categories are present in the dataset after label encoding?" +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/0046_178_46178687_qa_4/instruction.md b/tasks/0046_178_46178687_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..20b54f1c65e48622c11d8d9e22043afddbcfe88b --- /dev/null +++ b/tasks/0046_178_46178687_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum scaled PetalLengthCm value after MinMaxScaler preprocessing 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/0046_178_46178687_qa_4/task.toml b/tasks/0046_178_46178687_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4f13814b55a2037e5f51c2be970fc3b7ab6f14d1 --- /dev/null +++ b/tasks/0046_178_46178687_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0046_178_46178687_qa_4" +description = "What is the maximum scaled PetalLengthCm value after MinMaxScaler preprocessing in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0046/178/46178687.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "1" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "What is the maximum scaled PetalLengthCm value after MinMaxScaler preprocessing 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/0046_955_46955725_qa_4/instruction.md b/tasks/0046_955_46955725_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..00b2713745195fc6604c362d7ac8713fb3b8ee1f --- /dev/null +++ b/tasks/0046_955_46955725_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many games in the dataset resulted in team 2 winning under the condition that all six early game advantages were secured? + +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/0046_955_46955725_qa_4/task.toml b/tasks/0046_955_46955725_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..28171eb60a6ed795e5c25165bbd578f398d4f803 --- /dev/null +++ b/tasks/0046_955_46955725_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0046_955_46955725_qa_4" +description = "How many games in the dataset resulted in team 2 winning under the condition that all six early game advantages were secured?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0046/955/46955725.ipynb_qa_4" +kaggle_dataset_name = "datasnaek/league-of-legends" +gold_answer = "1648" +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 = "datasnaek__league-of-legends" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datasnaek/league-of-legends" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1648" +QUESTION = "How many games in the dataset resulted in team 2 winning under the condition that all six early game advantages were secured?" +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/0047_417_47417997_qa_3/instruction.md b/tasks/0047_417_47417997_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d6841846e5b43164fc9205a42e1baecbeca0d05b --- /dev/null +++ b/tasks/0047_417_47417997_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +For class 1 (Outcome=1) in the validation set, what was the F1-score achieved by the 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/0047_417_47417997_qa_3/task.toml b/tasks/0047_417_47417997_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..056e9d0640cba23d18643e7d0334e513ac6b6629 --- /dev/null +++ b/tasks/0047_417_47417997_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0047_417_47417997_qa_3" +description = "For class 1 (Outcome=1) in the validation set, what was the F1-score achieved by the model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0047/417/47417997.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0.651" +reward_mode_initial = "numeric" +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 = "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.651" +QUESTION = "For class 1 (Outcome=1) in the validation set, what was the F1-score achieved by the model?" +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/0047_852_47852416_qa_2/instruction.md b/tasks/0047_852_47852416_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..416698adc3fbffc36a736c0c2dd2047752a35868 --- /dev/null +++ b/tasks/0047_852_47852416_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): +- Womens Clothing E-Commerce Reviews.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which clothing department has the highest number of reviews 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/0047_852_47852416_qa_2/task.toml b/tasks/0047_852_47852416_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..33012b52670f0a840794d07dccc4b7e1e46b70dc --- /dev/null +++ b/tasks/0047_852_47852416_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0047_852_47852416_qa_2" +description = "Which clothing department has the highest number of reviews in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0047/852/47852416.ipynb_qa_2" +kaggle_dataset_name = "nicapotato/womens-ecommerce-clothing-reviews" +gold_answer = "Tops" +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 = "nicapotato__womens-ecommerce-clothing-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nicapotato/womens-ecommerce-clothing-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Tops" +QUESTION = "Which clothing department has the highest number of reviews 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/0048_436_48436455_qa_2/instruction.md b/tasks/0048_436_48436455_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..15318698fa9b3c6cb3eb70d6826492a8b9e40857 --- /dev/null +++ b/tasks/0048_436_48436455_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): +- GlobalLandTemperaturesByMajorCity.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many temperature recordings were available in the dataset after filtering for Surabaya and restricting the time range to data starting from 1869? + +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/0048_436_48436455_qa_2/task.toml b/tasks/0048_436_48436455_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..149fb4f1e4d1272c00e19e64f0e2323ebe3692bb --- /dev/null +++ b/tasks/0048_436_48436455_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0048_436_48436455_qa_2" +description = "How many temperature recordings were available in the dataset after filtering for Surabaya and restricting the time range to data starting from 1869?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0048/436/48436455.ipynb_qa_2" +kaggle_dataset_name = "berkeleyearth/climate-change-earth-surface-temperature-data" +gold_answer = "1737" +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 = "berkeleyearth__climate-change-earth-surface-temperature-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "berkeleyearth/climate-change-earth-surface-temperature-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1737" +QUESTION = "How many temperature recordings were available in the dataset after filtering for Surabaya and restricting the time range to data starting from 1869?" +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/0048_966_48966571_qa_3/instruction.md b/tasks/0048_966_48966571_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..27829114d39b95750b61b215f31e49c28aca21e0 --- /dev/null +++ b/tasks/0048_966_48966571_qa_3/instruction.md @@ -0,0 +1,19 @@ +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): +- movies_metadata.csv +- links_small.csv +- credits.csv +- keywords.csv +- ratings_small.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Using content-based recommendations, which movie is most similar to "The Dark Knight" based on TF-IDF description 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/0048_966_48966571_qa_3/task.toml b/tasks/0048_966_48966571_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c6a57d109102572676d457a30993b0a4f60af13b --- /dev/null +++ b/tasks/0048_966_48966571_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0048_966_48966571_qa_3" +description = "Using content-based recommendations, which movie is most similar to \"The Dark Knight\" based on TF-IDF description analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0048/966/48966571.ipynb_qa_3" +kaggle_dataset_name = "rounakbanik/the-movies-dataset" +gold_answer = "The Dark Knight Rises" +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 = "rounakbanik__the-movies-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rounakbanik/the-movies-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "The Dark Knight Rises" +QUESTION = "Using content-based recommendations, which movie is most similar to \"The Dark Knight\" based on TF-IDF description analysis?" +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/0049_078_49078403_qa_1/instruction.md b/tasks/0049_078_49078403_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..af96b477eb5e32b8119b95990424a352f9f470ff --- /dev/null +++ b/tasks/0049_078_49078403_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest correlation with the Outcome variable according to the heatmap 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/0049_078_49078403_qa_1/task.toml b/tasks/0049_078_49078403_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..487e5a67a5693000dd88485c5e345450f0d2f9c8 --- /dev/null +++ b/tasks/0049_078_49078403_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0049_078_49078403_qa_1" +description = "Which feature has the highest correlation with the Outcome variable according to the heatmap analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0049/078/49078403.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +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__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 = "Which feature has the highest correlation with the Outcome variable according to the heatmap analysis?" +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/0049_482_49482971_qa_2/instruction.md b/tasks/0049_482_49482971_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e2cafb03fc86ed24e3e24c9877aeadfa9f238215 --- /dev/null +++ b/tasks/0049_482_49482971_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: +Which gaming platform has achieved the highest total global sales 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/0049_482_49482971_qa_2/task.toml b/tasks/0049_482_49482971_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3ec29ec379a40228f366c4ad47c451ca1dd8bb0e --- /dev/null +++ b/tasks/0049_482_49482971_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0049_482_49482971_qa_2" +description = "Which gaming platform has achieved the highest total global sales in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0049/482/49482971.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "PS2" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PS2" +QUESTION = "Which gaming platform has achieved the highest total global sales 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/0049_738_49738137_qa_5/instruction.md b/tasks/0049_738_49738137_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f3fe438b631642f211ff290e61740c1fe498edf0 --- /dev/null +++ b/tasks/0049_738_49738137_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): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average value of the Sp. Atk stat for all Pokémon 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/0049_738_49738137_qa_5/task.toml b/tasks/0049_738_49738137_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..138f18199a239be1bf51ec246f9d8ce0fb7e9b3c --- /dev/null +++ b/tasks/0049_738_49738137_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0049_738_49738137_qa_5" +description = "What is the average value of the Sp. Atk stat for all Pokémon in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0049/738/49738137.ipynb_qa_5" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "72.82" +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 = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "72.82" +QUESTION = "What is the average value of the Sp. Atk stat for all Pokémon 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/0049_804_49804423_qa_2/instruction.md b/tasks/0049_804_49804423_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..22d464820845a92f7637f29d48e94bc700cd7fbb --- /dev/null +++ b/tasks/0049_804_49804423_qa_2/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mathematical equation of the linear regression line derived from the training 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/0049_804_49804423_qa_2/task.toml b/tasks/0049_804_49804423_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1b735d53734440014f4d59d48a412bae396263db --- /dev/null +++ b/tasks/0049_804_49804423_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0049_804_49804423_qa_2" +description = "What is the mathematical equation of the linear regression line derived from the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0049/804/49804423.ipynb_qa_2" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "y = 1.00065638x - 0.10726546" +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 = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "y = 1.00065638x - 0.10726546" +QUESTION = "What is the mathematical equation of the linear regression line derived from the training 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/0050_022_50022943_qa_1/instruction.md b/tasks/0050_022_50022943_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..93e5c09c67d0253788d21ba70b7ec958d6a94ddf --- /dev/null +++ b/tasks/0050_022_50022943_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 highest correlation coefficient between any two features 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/0050_022_50022943_qa_1/task.toml b/tasks/0050_022_50022943_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d37d326927c0319c6336305a0dd52842f34694ac --- /dev/null +++ b/tasks/0050_022_50022943_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0050_022_50022943_qa_1" +description = "What is the highest correlation coefficient between any two features in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0050/022/50022943.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.962757" +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 = "0.962757" +QUESTION = "What is the highest correlation coefficient between any two features 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/0050_224_50224594_qa_5/instruction.md b/tasks/0050_224_50224594_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8a39a9366df1b4d23ed7aa7135df73fc6b0bf15c --- /dev/null +++ b/tasks/0050_224_50224594_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): +- parkinsons2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean value of the MDVP:Fhi(Hz) feature across all samples 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/0050_224_50224594_qa_5/task.toml b/tasks/0050_224_50224594_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a4ed2e098934e5b6063c26f3f7b37c93d6936fd6 --- /dev/null +++ b/tasks/0050_224_50224594_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0050_224_50224594_qa_5" +description = "What is the mean value of the MDVP:Fhi(Hz) feature across all samples in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0050/224/50224594.ipynb_qa_5" +kaggle_dataset_name = "guywhowantstolearnml/parkinsonsxyz" +gold_answer = "197.104918" +reward_mode_initial = "numeric" +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 = "guywhowantstolearnml__parkinsonsxyz" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "guywhowantstolearnml/parkinsonsxyz" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "197.104918" +QUESTION = "What is the mean value of the MDVP:Fhi(Hz) feature across all samples 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/0050_797_50797720_qa_5/instruction.md b/tasks/0050_797_50797720_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..08df8d4fe4183f66c5a63773efa62d72517ee935 --- /dev/null +++ b/tasks/0050_797_50797720_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of respondents believe that discussing a mental health issue with their employer would have negative consequences? + +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/0050_797_50797720_qa_5/task.toml b/tasks/0050_797_50797720_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..95e4f7f35c05e5e73d1f8e3d582c7cc2eeb5e0bc --- /dev/null +++ b/tasks/0050_797_50797720_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0050_797_50797720_qa_5" +description = "What percentage of respondents believe that discussing a mental health issue with their employer would have negative consequences?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0050/797/50797720.ipynb_qa_5" +kaggle_dataset_name = "osmi/mental-health-in-tech-survey" +gold_answer = "22.98" +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 = "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 = "22.98" +QUESTION = "What percentage of respondents believe that discussing a mental health issue with their employer would have negative consequences?" +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/0050_812_50812874_qa_3/instruction.md b/tasks/0050_812_50812874_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a9c4fccb2f89dc0c0536920fc8efd01c3cb2648b --- /dev/null +++ b/tasks/0050_812_50812874_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): +- X.npy +- Y.npy + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which digit class in the test set has the highest precision according to the classification report? + +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/0050_812_50812874_qa_3/task.toml b/tasks/0050_812_50812874_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..89e52c68ab9eab173f311abdd1e4373e71304271 --- /dev/null +++ b/tasks/0050_812_50812874_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0050_812_50812874_qa_3" +description = "Which digit class in the test set has the highest precision according to the classification report?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0050/812/50812874.ipynb_qa_3" +kaggle_dataset_name = "ardamavi/sign-language-digits-dataset" +gold_answer = "1" +reward_mode_initial = "exact_short" +package_tier = 2 +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 = "ardamavi__sign-language-digits-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ardamavi/sign-language-digits-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "Which digit class in the test set has the highest precision according to the classification report?" +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/0051_525_51525477_qa_1/instruction.md b/tasks/0051_525_51525477_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..14c93837cc7ca9a466e100ef488ed400df94fead --- /dev/null +++ b/tasks/0051_525_51525477_qa_1/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of missing values were present in the Product_Category_3 column of the training dataset before imputation? + +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/0051_525_51525477_qa_1/task.toml b/tasks/0051_525_51525477_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f76501805c500a7275e8c7c04f72078e97bb20f3 --- /dev/null +++ b/tasks/0051_525_51525477_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0051_525_51525477_qa_1" +description = "What percentage of missing values were present in the Product_Category_3 column of the training dataset before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0051/525/51525477.ipynb_qa_1" +kaggle_dataset_name = "sdolezel/black-friday" +gold_answer = "69.7" +reward_mode_initial = "numeric" +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 = "sdolezel__black-friday" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sdolezel/black-friday" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "69.7" +QUESTION = "What percentage of missing values were present in the Product_Category_3 column of the training dataset before imputation?" +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/0051_529_51529879_qa_4/instruction.md b/tasks/0051_529_51529879_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..75a42a85c63089fb660bb22e860f644cf3700d16 --- /dev/null +++ b/tasks/0051_529_51529879_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 correlation between radius_worst and area_worst 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/0051_529_51529879_qa_4/task.toml b/tasks/0051_529_51529879_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fe1134f6e293e102271bf468c3a03477748af6e0 --- /dev/null +++ b/tasks/0051_529_51529879_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0051_529_51529879_qa_4" +description = "What is the correlation between radius_worst and area_worst in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0051/529/51529879.ipynb_qa_4" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.96" +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__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 = "0.96" +QUESTION = "What is the correlation between radius_worst and area_worst 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/0051_653_51653330_qa_5/instruction.md b/tasks/0051_653_51653330_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e18ccef8252fca0365bc6c6c059bfec8f0037392 --- /dev/null +++ b/tasks/0051_653_51653330_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Indian state has the highest total value of property stolen 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/0051_653_51653330_qa_5/task.toml b/tasks/0051_653_51653330_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6ab9014af594ec500b8dcaef9f62b0ae86a241f9 --- /dev/null +++ b/tasks/0051_653_51653330_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0051_653_51653330_qa_5" +description = "Which Indian state has the highest total value of property stolen in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0051/653/51653330.ipynb_qa_5" +kaggle_dataset_name = "rajanand/crime-in-india" +gold_answer = "Maharashtra" +reward_mode_initial = "exact_short" +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 = "rajanand__crime-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/crime-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Maharashtra" +QUESTION = "Which Indian state has the highest total value of property stolen 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/0051_975_51975834_qa_4/instruction.md b/tasks/0051_975_51975834_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..22bfc80ee001fd2acbea33b16600b11629260291 --- /dev/null +++ b/tasks/0051_975_51975834_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the R-squared value for the best model 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/0051_975_51975834_qa_4/task.toml b/tasks/0051_975_51975834_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..791412ee912f6bb86e60d0e20d3fd23425cf2cda --- /dev/null +++ b/tasks/0051_975_51975834_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0051_975_51975834_qa_4" +description = "What is the R-squared value for the best model on the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0051/975/51975834.ipynb_qa_4" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "0.98108479806778" +reward_mode_initial = "numeric" +package_tier = 2 +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.98108479806778" +QUESTION = "What is the R-squared value for the best model on the test set?" +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_471_52471814_qa_1/instruction.md b/tasks/0052_471_52471814_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e3d91ca6e13070a82b8a9b599ac260c1cafc818b --- /dev/null +++ b/tasks/0052_471_52471814_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which diamond cut has the highest frequency 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/0052_471_52471814_qa_1/task.toml b/tasks/0052_471_52471814_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cdd9f54183af97bcbd09f5518c7f1a10a45a589e --- /dev/null +++ b/tasks/0052_471_52471814_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0052_471_52471814_qa_1" +description = "Which diamond cut has the highest frequency in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0052/471/52471814.ipynb_qa_1" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "Ideal" +reward_mode_initial = "exact_short" +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Ideal" +QUESTION = "Which diamond cut has the highest frequency 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/0052_587_52587517_qa_3/instruction.md b/tasks/0052_587_52587517_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4837ff0815284106a8efc0449f47d5abf5d7eeee --- /dev/null +++ b/tasks/0052_587_52587517_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the minimum value in the 'Species' column after data standardization but before converting to integer data type? + +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_587_52587517_qa_3/task.toml b/tasks/0052_587_52587517_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..91693b6a1135d903f6ced18d7ac92760b3f0a11d --- /dev/null +++ b/tasks/0052_587_52587517_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0052_587_52587517_qa_3" +description = "What was the minimum value in the 'Species' column after data standardization but before converting to integer data type?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0052/587/52587517.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "-1.224745" +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 = "-1.224745" +QUESTION = "What was the minimum value in the 'Species' column after data standardization but before converting to integer data type?" +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_587_52587517_qa_4/instruction.md b/tasks/0052_587_52587517_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ba67ef2239d3cd35969b9cd4a26d2ed9f4152264 --- /dev/null +++ b/tasks/0052_587_52587517_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature had the largest range (difference between maximum and minimum values) in the original dataset before any preprocessing? + +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_587_52587517_qa_4/task.toml b/tasks/0052_587_52587517_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..49cf021735df83f994defa464b6bb57e696b6158 --- /dev/null +++ b/tasks/0052_587_52587517_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0052_587_52587517_qa_4" +description = "Which feature had the largest range (difference between maximum and minimum values) in the original dataset before any preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0052/587/52587517.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalLengthCm" +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 = "PetalLengthCm" +QUESTION = "Which feature had the largest range (difference between maximum and minimum values) in the original dataset before any preprocessing?" +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/0052_868_52868530_qa_4/instruction.md b/tasks/0052_868_52868530_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f43ef2a05e92bc83857b8b5e4c434feb9a99a759 --- /dev/null +++ b/tasks/0052_868_52868530_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature exhibits the strongest average correlation with the Outcome variable (diabetes diagnosis) across all features 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/0052_868_52868530_qa_4/task.toml b/tasks/0052_868_52868530_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9bb1667297db1892190b2fc622c3af7921f086eb --- /dev/null +++ b/tasks/0052_868_52868530_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0052_868_52868530_qa_4" +description = "Which feature exhibits the strongest average correlation with the Outcome variable (diabetes diagnosis) across all features in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0052/868/52868530.ipynb_qa_4" +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 = "Which feature exhibits the strongest average correlation with the Outcome variable (diabetes diagnosis) across all features 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/0053_327_53327790_qa_3/instruction.md b/tasks/0053_327_53327790_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..36cc6a84873bb6ef016bf4105c3d592416c9e9f8 --- /dev/null +++ b/tasks/0053_327_53327790_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): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of districts in the dataset are categorized as "NEAR OCEAN" in the ocean_proximity field? + +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/0053_327_53327790_qa_3/task.toml b/tasks/0053_327_53327790_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8e2a841e18f1755fd607858afb178cdbb3e505c1 --- /dev/null +++ b/tasks/0053_327_53327790_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0053_327_53327790_qa_3" +description = "What percentage of districts in the dataset are categorized as \"NEAR OCEAN\" in the ocean_proximity field?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0053/327/53327790.ipynb_qa_3" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "12.88" +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 = "12.88" +QUESTION = "What percentage of districts in the dataset are categorized as \"NEAR OCEAN\" in the ocean_proximity field?" +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/0053_352_53352624_qa_1/instruction.md b/tasks/0053_352_53352624_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8d0c7e2a9fd7222ebe6bd80b895274dec2d76c18 --- /dev/null +++ b/tasks/0053_352_53352624_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): +- carInsurance_train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which job category has the highest percentage of customers accepting the car insurance policy according to the dataset 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/0053_352_53352624_qa_1/task.toml b/tasks/0053_352_53352624_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2630ba03911e391ba657adc147daae837e84c8e2 --- /dev/null +++ b/tasks/0053_352_53352624_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0053_352_53352624_qa_1" +description = "Which job category has the highest percentage of customers accepting the car insurance policy according to the dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0053/352/53352624.ipynb_qa_1" +kaggle_dataset_name = "kondla/carinsurance" +gold_answer = "student" +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 = "kondla__carinsurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kondla/carinsurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "student" +QUESTION = "Which job category has the highest percentage of customers accepting the car insurance policy according to the dataset analysis?" +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/0053_426_53426290_qa_3/instruction.md b/tasks/0053_426_53426290_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..319d026783d2bd44e5dbea4df92fecfa23a3cc37 --- /dev/null +++ b/tasks/0053_426_53426290_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): +- prices-split-adjusted.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 opening prices across all stocks 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/0053_426_53426290_qa_3/task.toml b/tasks/0053_426_53426290_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..59b8bc668bf0b16e127277d27620d3d774a17024 --- /dev/null +++ b/tasks/0053_426_53426290_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0053_426_53426290_qa_3" +description = "What is the standard deviation of the opening prices across all stocks in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0053/426/53426290.ipynb_qa_3" +kaggle_dataset_name = "dgawlik/nyse" +gold_answer = "75.203893" +reward_mode_initial = "numeric" +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 = "dgawlik__nyse" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dgawlik/nyse" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "75.203893" +QUESTION = "What is the standard deviation of the opening prices across all stocks 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/0054_315_54315694_qa_2/instruction.md b/tasks/0054_315_54315694_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5252325e1f7150dfd705aa8613f23d661c88a904 --- /dev/null +++ b/tasks/0054_315_54315694_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): +- all_energy_statistics.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique years are present in the dataset after data cleaning and preprocessing? + +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_315_54315694_qa_2/task.toml b/tasks/0054_315_54315694_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fad29bc929fa1d86d1452a183ecc10bd17c0ff93 --- /dev/null +++ b/tasks/0054_315_54315694_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0054_315_54315694_qa_2" +description = "How many unique years are present in the dataset after data cleaning and preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0054/315/54315694.ipynb_qa_2" +kaggle_dataset_name = "unitednations/international-energy-statistics" +gold_answer = "25" +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 = "unitednations__international-energy-statistics" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "unitednations/international-energy-statistics" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "25" +QUESTION = "How many unique years are present in the dataset after data cleaning and preprocessing?" +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_739_54739768_qa_1/instruction.md b/tasks/0054_739_54739768_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..512ed0a430a5ac89e8f7d9464ad3bce7f002285d --- /dev/null +++ b/tasks/0054_739_54739768_qa_1/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): +- train.csv +- test.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 original training dataset before the NaN value 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/0054_739_54739768_qa_1/task.toml b/tasks/0054_739_54739768_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ad4435a3dc062ec63e81896b40b619859c1d794c --- /dev/null +++ b/tasks/0054_739_54739768_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0054_739_54739768_qa_1" +description = "How many missing values were present in the original training dataset before the NaN value cleaning process?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0054/739/54739768.ipynb_qa_1" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "1" +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 = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "How many missing values were present in the original training dataset before the NaN value 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/0054_801_54801630_qa_2/instruction.md b/tasks/0054_801_54801630_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6022b2fcaa73e6f82d60c40f000dc0c2acdc739b --- /dev/null +++ b/tasks/0054_801_54801630_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): +- Pakistan Intellectual Capital - Computer Science - Ver 1.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common terminal degree among faculty members after standardizing the degree categories? + +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_801_54801630_qa_2/task.toml b/tasks/0054_801_54801630_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..056d7d7091de0f6939f277f9cc3fd1c1978ebeb5 --- /dev/null +++ b/tasks/0054_801_54801630_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0054_801_54801630_qa_2" +description = "What is the most common terminal degree among faculty members after standardizing the degree categories?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0054/801/54801630.ipynb_qa_2" +kaggle_dataset_name = "zusmani/pakistanintellectualcapitalcs" +gold_answer = "MS" +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 = "zusmani__pakistanintellectualcapitalcs" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zusmani/pakistanintellectualcapitalcs" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "MS" +QUESTION = "What is the most common terminal degree among faculty members after standardizing the degree categories?" +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/0055_042_55042891_qa_4/instruction.md b/tasks/0055_042_55042891_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1ef86a3e0bd2518ffe651963af21ce778859690d --- /dev/null +++ b/tasks/0055_042_55042891_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): +- diabetes.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 'Insulin' column in the original 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/0055_042_55042891_qa_4/task.toml b/tasks/0055_042_55042891_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..002cab45e288cb8030b8f7c6b58d530c9a65e810 --- /dev/null +++ b/tasks/0055_042_55042891_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0055_042_55042891_qa_4" +description = "What is the standard deviation of the 'Insulin' column in the original dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0055/042/55042891.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "115.24" +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__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 = "115.24" +QUESTION = "What is the standard deviation of the 'Insulin' column in the original 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/0055_790_55790118_qa_3/instruction.md b/tasks/0055_790_55790118_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1d07a4d699e23eb9fd469365137480fb13046ace --- /dev/null +++ b/tasks/0055_790_55790118_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which occupation has the highest number of individuals in the dataset, and what is that count? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, plain number). + +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_790_55790118_qa_3/task.toml b/tasks/0055_790_55790118_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c0356c253fd190d64fea129b9b051f2ae95f3088 --- /dev/null +++ b/tasks/0055_790_55790118_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0055_790_55790118_qa_3" +description = "Which occupation has the highest number of individuals in the dataset, and what is that count?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0055/790/55790118.ipynb_qa_3" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "Prof-specialty, 4140" +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 = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Prof-specialty, 4140" +QUESTION = "Which occupation has the highest number of individuals in the dataset, and what is that count?" +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/0055_824_55824440_qa_3/instruction.md b/tasks/0055_824_55824440_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7e607c91058c9580fdfc76124df6d9d5d7c81b6c --- /dev/null +++ b/tasks/0055_824_55824440_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: +Which feature shows the highest correlation with the diabetes outcome (Outcome=1) based on the correlation 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/0055_824_55824440_qa_3/task.toml b/tasks/0055_824_55824440_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..831dcebe44b5e468afab00d1bfcba00adc2567d7 --- /dev/null +++ b/tasks/0055_824_55824440_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0055_824_55824440_qa_3" +description = "Which feature shows the highest correlation with the diabetes outcome (Outcome=1) based on the correlation analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0055/824/55824440.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +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__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 = "Which feature shows the highest correlation with the diabetes outcome (Outcome=1) based on the correlation analysis?" +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/0056_391_56391883_qa_3/instruction.md b/tasks/0056_391_56391883_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..61ebc366119c94f9b8636c85b4912c1f3b472923 --- /dev/null +++ b/tasks/0056_391_56391883_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): +- Suicides in India 2001-2012.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +In which year between 2001 and 2012 was the total number of suicides the highest? + +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_391_56391883_qa_3/task.toml b/tasks/0056_391_56391883_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..309e25690641ab9a8cbf071e6f232016e90dd9dd --- /dev/null +++ b/tasks/0056_391_56391883_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0056_391_56391883_qa_3" +description = "In which year between 2001 and 2012 was the total number of suicides the highest?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/391/56391883.ipynb_qa_3" +kaggle_dataset_name = "rajanand/suicides-in-india" +gold_answer = "2011" +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 = "rajanand__suicides-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/suicides-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2011" +QUESTION = "In which year between 2001 and 2012 was the total number of suicides the highest?" +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/0056_391_56391883_qa_4/instruction.md b/tasks/0056_391_56391883_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..351f24741d2cd281664955e1c85b1022b090ddc5 --- /dev/null +++ b/tasks/0056_391_56391883_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): +- Suicides in India 2001-2012.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Among the listed causes of suicide, which specific cause has the highest total count 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_391_56391883_qa_4/task.toml b/tasks/0056_391_56391883_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8d3bf9cd6f638b99d61f5406deed63980c009884 --- /dev/null +++ b/tasks/0056_391_56391883_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0056_391_56391883_qa_4" +description = "Among the listed causes of suicide, which specific cause has the highest total count in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/391/56391883.ipynb_qa_4" +kaggle_dataset_name = "rajanand/suicides-in-india" +gold_answer = "Family Problems" +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 = "rajanand__suicides-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/suicides-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Family Problems" +QUESTION = "Among the listed causes of suicide, which specific cause has the highest total count 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/0056_687_56687302_qa_2/instruction.md b/tasks/0056_687_56687302_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f0a20c1e25dfccc713846baabae226c6b1d8574e --- /dev/null +++ b/tasks/0056_687_56687302_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): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which product description appears most frequently in the cleaned dataset, and how many times was it purchased? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, description first, count as a plain number). + +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_687_56687302_qa_2/task.toml b/tasks/0056_687_56687302_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e3c752e205132e5de46189f2aa118bb48abf625d --- /dev/null +++ b/tasks/0056_687_56687302_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0056_687_56687302_qa_2" +description = "Which product description appears most frequently in the cleaned dataset, and how many times was it purchased?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/687/56687302.ipynb_qa_2" +kaggle_dataset_name = "carrie1/ecommerce-data" +gold_answer = "WHITE HANGING HEART T-LIGHT HOLDER, 2028" +reward_mode_initial = "list" +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 = "WHITE HANGING HEART T-LIGHT HOLDER, 2028" +QUESTION = "Which product description appears most frequently in the cleaned dataset, and how many times was it purchased?" +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/0056_748_56748033_qa_1/instruction.md b/tasks/0056_748_56748033_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3fd6dad41e607f69956713fd5bace4978508be70 --- /dev/null +++ b/tasks/0056_748_56748033_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): +- UCI_Credit_Card.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of customers in the dataset who defaulted on their credit card payments (target class 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/0056_748_56748033_qa_1/task.toml b/tasks/0056_748_56748033_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..22ddc53f1c77d956db52e4e248d8b117d490def3 --- /dev/null +++ b/tasks/0056_748_56748033_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0056_748_56748033_qa_1" +description = "What is the percentage of customers in the dataset who defaulted on their credit card payments (target class distribution)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/748/56748033.ipynb_qa_1" +kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset" +gold_answer = "22.12" +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__default-of-credit-card-clients-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "22.12" +QUESTION = "What is the percentage of customers in the dataset who defaulted on their credit card payments (target class 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/0056_907_56907084_qa_3/instruction.md b/tasks/0056_907_56907084_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3b7352ac31d85fb2ab39ae5bf085145a77a46ac2 --- /dev/null +++ b/tasks/0056_907_56907084_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean absolute error (MAE) of the linear regression model 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/0056_907_56907084_qa_3/task.toml b/tasks/0056_907_56907084_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6eb3004b0ce69a29cde3304ac47d3f713b5b3f1a --- /dev/null +++ b/tasks/0056_907_56907084_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0056_907_56907084_qa_3" +description = "What is the mean absolute error (MAE) of the linear regression model on the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/907/56907084.ipynb_qa_3" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "4037.16" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4037.16" +QUESTION = "What is the mean absolute error (MAE) of the linear regression model 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/0057_721_57721830_qa_1/instruction.md b/tasks/0057_721_57721830_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8aa6f5b601e9cab62a2f558f4342e6862c7db6e6 --- /dev/null +++ b/tasks/0057_721_57721830_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): +- matches.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which team has won the most seasons in the IPL 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/0057_721_57721830_qa_1/task.toml b/tasks/0057_721_57721830_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7f46ef881633251c08ad13828eb6c874991be9b2 --- /dev/null +++ b/tasks/0057_721_57721830_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0057_721_57721830_qa_1" +description = "Which team has won the most seasons in the IPL according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0057/721/57721830.ipynb_qa_1" +kaggle_dataset_name = "manasgarg/ipl" +gold_answer = "Mumbai Indians" +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 = "manasgarg__ipl" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "manasgarg/ipl" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Mumbai Indians" +QUESTION = "Which team has won the most seasons in the IPL according to 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/0057_925_57925686_qa_2/instruction.md b/tasks/0057_925_57925686_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3514845b24ccc9a23e31647204eb5cdcefde919d --- /dev/null +++ b/tasks/0057_925_57925686_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): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the accuracy score of the Support Vector Classifier (SVC) 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/0057_925_57925686_qa_2/task.toml b/tasks/0057_925_57925686_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6f6907862a27ecb07ac08faa323565a471c7be83 --- /dev/null +++ b/tasks/0057_925_57925686_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0057_925_57925686_qa_2" +description = "What is the accuracy score of the Support Vector Classifier (SVC) on the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0057/925/57925686.ipynb_qa_2" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "0.982057" +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__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 = "0.982057" +QUESTION = "What is the accuracy score of the Support Vector Classifier (SVC) on the test set?" +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/0059_000_59000863_qa_2/instruction.md b/tasks/0059_000_59000863_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1c898d8b1df53034e24fabb88a1d787edfc11d3a --- /dev/null +++ b/tasks/0059_000_59000863_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 distribution of species in the dataset based on the value counts? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the counts. + +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/0059_000_59000863_qa_2/task.toml b/tasks/0059_000_59000863_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f8b6fdb76543f46027eaee7beb06d7641967021f --- /dev/null +++ b/tasks/0059_000_59000863_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0059_000_59000863_qa_2" +description = "What is the distribution of species in the dataset based on the value counts?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0059/000/59000863.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "50, 50, 50" +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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "50, 50, 50" +QUESTION = "What is the distribution of species in the dataset based on the value counts?" +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/0059_523_59523535_qa_3/instruction.md b/tasks/0059_523_59523535_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..02f6cff52ba1c41fdb8e061fd81db928a1f811ce --- /dev/null +++ b/tasks/0059_523_59523535_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): +- SPAM text message 20170820 - Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many samples were allocated to the training set after splitting the dataset with a 0.2 test size ratio? + +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/0059_523_59523535_qa_3/task.toml b/tasks/0059_523_59523535_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d34ee25d135ad7c0ba732c043669af9260758f10 --- /dev/null +++ b/tasks/0059_523_59523535_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0059_523_59523535_qa_3" +description = "How many samples were allocated to the training set after splitting the dataset with a 0.2 test size ratio?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0059/523/59523535.ipynb_qa_3" +kaggle_dataset_name = "team-ai/spam-text-message-classification" +gold_answer = "4457" +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 = "team-ai__spam-text-message-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "team-ai/spam-text-message-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4457" +QUESTION = "How many samples were allocated to the training set after splitting the dataset with a 0.2 test size ratio?" +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/0060_490_60490802_qa_1/instruction.md b/tasks/0060_490_60490802_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dea3a5bac013e70f420da9ddf3cc4eafc9a51cbd --- /dev/null +++ b/tasks/0060_490_60490802_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which categorical variable (cut, color, or clarity) has the highest F-statistic in the ANOVA analysis when predicting diamond prices? + +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/0060_490_60490802_qa_1/task.toml b/tasks/0060_490_60490802_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1e3c29c9eaa11647e02dbef7a67e182bc30514b8 --- /dev/null +++ b/tasks/0060_490_60490802_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0060_490_60490802_qa_1" +description = "Which categorical variable (cut, color, or clarity) has the highest F-statistic in the ANOVA analysis when predicting diamond prices?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0060/490/60490802.ipynb_qa_1" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "color" +QUESTION = "Which categorical variable (cut, color, or clarity) has the highest F-statistic in the ANOVA analysis when predicting diamond prices?" +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/0061_998_61998767_qa_3/instruction.md b/tasks/0061_998_61998767_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..af5a75349a78cee2f4eab6bcf09e3a2d460f1077 --- /dev/null +++ b/tasks/0061_998_61998767_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): +- Social_Network_Ads.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Does the EstimatedSalary variable have a positive or negative impact on the likelihood of purchasing according to the logistic 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/0061_998_61998767_qa_3/task.toml b/tasks/0061_998_61998767_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0d87f5d6cb76808e6fded2a01500755431425f9a --- /dev/null +++ b/tasks/0061_998_61998767_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0061_998_61998767_qa_3" +description = "Does the EstimatedSalary variable have a positive or negative impact on the likelihood of purchasing according to the logistic regression model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0061/998/61998767.ipynb_qa_3" +kaggle_dataset_name = "dragonheir/logistic-regression" +gold_answer = "positive" +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 = "dragonheir__logistic-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dragonheir/logistic-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "positive" +QUESTION = "Does the EstimatedSalary variable have a positive or negative impact on the likelihood of purchasing according to the logistic regression model?" +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/0062_391_62391096_qa_3/instruction.md b/tasks/0062_391_62391096_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fee60946a2965b7007623477315648da7e0de4a1 --- /dev/null +++ b/tasks/0062_391_62391096_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Are the distributions of age, bmi, and charges approximately normal according to the Shapiro-Wilk test 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/0062_391_62391096_qa_3/task.toml b/tasks/0062_391_62391096_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c862d1376b155a3fbe188dd85695a18d6b0166b7 --- /dev/null +++ b/tasks/0062_391_62391096_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0062_391_62391096_qa_3" +description = "Are the distributions of age, bmi, and charges approximately normal according to the Shapiro-Wilk test results?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0062/391/62391096.ipynb_qa_3" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "no" +reward_mode_initial = "exact_bool" +package_tier = 2 +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 = "no" +QUESTION = "Are the distributions of age, bmi, and charges approximately normal according to the Shapiro-Wilk test results?" +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/0062_945_62945279_qa_3/instruction.md b/tasks/0062_945_62945279_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6364a3616c0bca37e5ee14ecf863c9aa67b2aa75 --- /dev/null +++ b/tasks/0062_945_62945279_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What variable has the highest positive coefficient in the Logistic Regression model for predicting churn? + +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_945_62945279_qa_3/task.toml b/tasks/0062_945_62945279_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e476d9313786f12d6bafad645595e7f057c6aa1f --- /dev/null +++ b/tasks/0062_945_62945279_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0062_945_62945279_qa_3" +description = "What variable has the highest positive coefficient in the Logistic Regression model for predicting churn?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0062/945/62945279.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Contract_Month-to-month" +reward_mode_initial = "exact_short" +package_tier = 2 +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Contract_Month-to-month" +QUESTION = "What variable has the highest positive coefficient in the Logistic Regression model for predicting churn?" +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/0063_056_63056064_qa_2/instruction.md b/tasks/0063_056_63056064_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a845ee67a0e6991898c001d79246725021f38bb0 --- /dev/null +++ b/tasks/0063_056_63056064_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): +- auto-mpg.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 'horsepower' column before imputation? + +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/0063_056_63056064_qa_2/task.toml b/tasks/0063_056_63056064_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..145cc00a6848bf07de8451bcd0c86b774f513064 --- /dev/null +++ b/tasks/0063_056_63056064_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0063_056_63056064_qa_2" +description = "How many missing values were present in the 'horsepower' column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0063/056/63056064.ipynb_qa_2" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "6" +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__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many missing values were present in the 'horsepower' column before imputation?" +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/0063_350_63350967_qa_3/instruction.md b/tasks/0063_350_63350967_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5799d9c5063161eed7347d4eb15cc0a042aec4bf --- /dev/null +++ b/tasks/0063_350_63350967_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): +- GlobalLandTemperaturesByState.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which country has the lowest average temperature in the dataset between 1980-2013 according to the grouped 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/0063_350_63350967_qa_3/task.toml b/tasks/0063_350_63350967_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..13c943b002b06afd9138dba4ea699f3fd7921654 --- /dev/null +++ b/tasks/0063_350_63350967_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0063_350_63350967_qa_3" +description = "Which country has the lowest average temperature in the dataset between 1980-2013 according to the grouped analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0063/350/63350967.ipynb_qa_3" +kaggle_dataset_name = "berkeleyearth/climate-change-earth-surface-temperature-data" +gold_answer = "Canada" +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 = "berkeleyearth__climate-change-earth-surface-temperature-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "berkeleyearth/climate-change-earth-surface-temperature-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Canada" +QUESTION = "Which country has the lowest average temperature in the dataset between 1980-2013 according to the grouped analysis?" +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/0063_468_63468812_qa_5/instruction.md b/tasks/0063_468_63468812_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1e6576452dd93146da0505efdfe9ab315a2cb105 --- /dev/null +++ b/tasks/0063_468_63468812_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: +Which independent variable has the highest positive Pearson correlation with the density of the wine? + +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/0063_468_63468812_qa_5/task.toml b/tasks/0063_468_63468812_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7691e8e74b8710f71e32d6a921903258056e882c --- /dev/null +++ b/tasks/0063_468_63468812_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0063_468_63468812_qa_5" +description = "Which independent variable has the highest positive Pearson correlation with the density of the wine?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0063/468/63468812.ipynb_qa_5" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "fixed acidity" +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__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 = "fixed acidity" +QUESTION = "Which independent variable has the highest positive Pearson correlation with the density of the wine?" +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/0063_490_63490471_qa_1/instruction.md b/tasks/0063_490_63490471_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..91a99be6a39ccdcae7041504b513f0fd981b85c5 --- /dev/null +++ b/tasks/0063_490_63490471_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which customer segment has the highest churn rate based on the combination of contract type and payment method? + +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/0063_490_63490471_qa_1/task.toml b/tasks/0063_490_63490471_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a15dbf56a55c48b25a2e62dba66d510445cc5c26 --- /dev/null +++ b/tasks/0063_490_63490471_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0063_490_63490471_qa_1" +description = "Which customer segment has the highest churn rate based on the combination of contract type and payment method?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0063/490/63490471.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Month-to-month contract with Electronic Check payment" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Month-to-month contract with Electronic Check payment" +QUESTION = "Which customer segment has the highest churn rate based on the combination of contract type and payment method?" +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/0064_267_64267004_qa_3/instruction.md b/tasks/0064_267_64267004_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fbcfb8f78718d4c386baaebf408785aaa536d939 --- /dev/null +++ b/tasks/0064_267_64267004_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: +What is the highest average radius value among the three types (mean, standard error, worst) 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/0064_267_64267004_qa_3/task.toml b/tasks/0064_267_64267004_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b47337d7cde18486b780b52d25a09c6784c68355 --- /dev/null +++ b/tasks/0064_267_64267004_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0064_267_64267004_qa_3" +description = "What is the highest average radius value among the three types (mean, standard error, worst) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/267/64267004.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "16.3" +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__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 = "16.3" +QUESTION = "What is the highest average radius value among the three types (mean, standard error, worst) 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/0064_330_64330026_qa_1/instruction.md b/tasks/0064_330_64330026_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f1f1fa8c2ee5557211bea7de9bb989403a2765ab --- /dev/null +++ b/tasks/0064_330_64330026_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): +- GlobalTemperatures.csv + +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 Augmented Dickey-Fuller test for the differenced time series after first-order differencing? + +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/0064_330_64330026_qa_1/task.toml b/tasks/0064_330_64330026_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e9fbe98f3ef4abf9d4241b417a18f987f05b45e9 --- /dev/null +++ b/tasks/0064_330_64330026_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0064_330_64330026_qa_1" +description = "What is the p-value from the Augmented Dickey-Fuller test for the differenced time series after first-order differencing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/330/64330026.ipynb_qa_1" +kaggle_dataset_name = "berkeleyearth/climate-change-earth-surface-temperature-data" +gold_answer = "9.755605e-22" +reward_mode_initial = "numeric" +package_tier = 2 +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 = "berkeleyearth__climate-change-earth-surface-temperature-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "berkeleyearth/climate-change-earth-surface-temperature-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "9.755605e-22" +QUESTION = "What is the p-value from the Augmented Dickey-Fuller test for the differenced time series after first-order differencing?" +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/0064_397_64397098_qa_3/instruction.md b/tasks/0064_397_64397098_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8b459eb5303687a73fc11dab70fcc39705ec30e9 --- /dev/null +++ b/tasks/0064_397_64397098_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of missing data in any column of 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/0064_397_64397098_qa_3/task.toml b/tasks/0064_397_64397098_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6ece2f5af3403cce9d555263d13e16497f0ebc50 --- /dev/null +++ b/tasks/0064_397_64397098_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0064_397_64397098_qa_3" +description = "What is the percentage of missing data in any column of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/397/64397098.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "What is the percentage of missing data in any column of 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/0064_698_64698192_qa_1/instruction.md b/tasks/0064_698_64698192_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..306622666884210abb031b468d443bb3c09dc535 --- /dev/null +++ b/tasks/0064_698_64698192_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest global sales value achieved by any video game 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/0064_698_64698192_qa_1/task.toml b/tasks/0064_698_64698192_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6c1b913300903e92b5521a2bfaa35af8e233f07b --- /dev/null +++ b/tasks/0064_698_64698192_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0064_698_64698192_qa_1" +description = "What is the highest global sales value achieved by any video game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/698/64698192.ipynb_qa_1" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "82.74" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82.74" +QUESTION = "What is the highest global sales value achieved by any video game 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/0064_766_64766227_qa_2/instruction.md b/tasks/0064_766_64766227_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ecb53a74f89c4dce4c892de2c561fb52230e2dce --- /dev/null +++ b/tasks/0064_766_64766227_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: +What is the mean age difference between patients who survived longer versus those who survived shorter periods (in 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/0064_766_64766227_qa_2/task.toml b/tasks/0064_766_64766227_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1a63488c6295c1af958bf0703d60b05f937ca13e --- /dev/null +++ b/tasks/0064_766_64766227_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0064_766_64766227_qa_2" +description = "What is the mean age difference between patients who survived longer versus those who survived shorter periods (in years)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/766/64766227.ipynb_qa_2" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "-1.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 = "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 = "-1.66" +QUESTION = "What is the mean age difference between patients who survived longer versus those who survived shorter periods (in years)?" +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/0064_983_64983007_qa_2/instruction.md b/tasks/0064_983_64983007_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ba2bf83d2c3f0fd14cf7daea4e0b781b71b640c7 --- /dev/null +++ b/tasks/0064_983_64983007_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: +Which feature showed the highest positive correlation with the 'Outcome' variable according to the correlation heatmap? + +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/0064_983_64983007_qa_2/task.toml b/tasks/0064_983_64983007_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..277f5bfec7db53baf4e3678f065b266de2a5d072 --- /dev/null +++ b/tasks/0064_983_64983007_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0064_983_64983007_qa_2" +description = "Which feature showed the highest positive correlation with the 'Outcome' variable according to the correlation heatmap?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/983/64983007.ipynb_qa_2" +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 = "Which feature showed the highest positive correlation with the 'Outcome' variable according to the correlation heatmap?" +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/0065_162_65162734_qa_3/instruction.md b/tasks/0065_162_65162734_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..565f3800864abb0574a2b66d9f71ae06d2a9468c --- /dev/null +++ b/tasks/0065_162_65162734_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: +What is the difference between the 75th percentile and 25th percentile of the radius_mean feature? + +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/0065_162_65162734_qa_3/task.toml b/tasks/0065_162_65162734_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ac9ce25e0c2f8a37558ccfce71c03a61c016fcbd --- /dev/null +++ b/tasks/0065_162_65162734_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0065_162_65162734_qa_3" +description = "What is the difference between the 75th percentile and 25th percentile of the radius_mean feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/162/65162734.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "4.08" +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__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 = "4.08" +QUESTION = "What is the difference between the 75th percentile and 25th percentile of the radius_mean feature?" +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/0065_504_65504512_qa_3/instruction.md b/tasks/0065_504_65504512_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ad176421bdfdf19663e22960b4b9f7d180cfb689 --- /dev/null +++ b/tasks/0065_504_65504512_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which region has the highest number of patients 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/0065_504_65504512_qa_3/task.toml b/tasks/0065_504_65504512_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c5aedfd51cf1b5459b96e1a25fedc774842a0736 --- /dev/null +++ b/tasks/0065_504_65504512_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0065_504_65504512_qa_3" +description = "Which region has the highest number of patients represented in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/504/65504512.ipynb_qa_3" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "Southeast" +reward_mode_initial = "exact_short" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Southeast" +QUESTION = "Which region has the highest number of patients represented 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/0065_504_65504512_qa_4/instruction.md b/tasks/0065_504_65504512_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dd8e94faf401f307a854d4df0e4f9f732186c7f0 --- /dev/null +++ b/tasks/0065_504_65504512_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which factor among age, body mass index (bmi), and number of children has the strongest positive correlation with medical charges 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/0065_504_65504512_qa_4/task.toml b/tasks/0065_504_65504512_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..487023e60531f818afe9fd292fcaa1ea4b114d4d --- /dev/null +++ b/tasks/0065_504_65504512_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0065_504_65504512_qa_4" +description = "Which factor among age, body mass index (bmi), and number of children has the strongest positive correlation with medical charges in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/504/65504512.ipynb_qa_4" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "age" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "age" +QUESTION = "Which factor among age, body mass index (bmi), and number of children has the strongest positive correlation with medical charges 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/0065_563_65563185_qa_4/instruction.md b/tasks/0065_563_65563185_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..40dac8121c1145b7cd37aa612d299f5a7d149b82 --- /dev/null +++ b/tasks/0065_563_65563185_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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the recall value for the minority class (class 1) in the XGBoost model's test set evaluation? + +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/0065_563_65563185_qa_4/task.toml b/tasks/0065_563_65563185_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5cd282144998821bff3c28ee91b6a7dcc3f361fe --- /dev/null +++ b/tasks/0065_563_65563185_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0065_563_65563185_qa_4" +description = "What is the recall value for the minority class (class 1) in the XGBoost model's test set evaluation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/563/65563185.ipynb_qa_4" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "0.61" +reward_mode_initial = "numeric" +package_tier = 2 +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__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 = "0.61" +QUESTION = "What is the recall value for the minority class (class 1) in the XGBoost model's test set evaluation?" +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/0065_745_65745045_qa_1/instruction.md b/tasks/0065_745_65745045_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..31a89d1156400473b2b1ccd1c20e50b0837bc325 --- /dev/null +++ b/tasks/0065_745_65745045_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): +- Womens Clothing E-Commerce Reviews.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequently occurring unigram in the reviews before removing stop words? + +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/0065_745_65745045_qa_1/task.toml b/tasks/0065_745_65745045_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e908cf77c83dc5c489c57340e6b8ebd8a1e363f4 --- /dev/null +++ b/tasks/0065_745_65745045_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0065_745_65745045_qa_1" +description = "What is the most frequently occurring unigram in the reviews before removing stop words?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/745/65745045.ipynb_qa_1" +kaggle_dataset_name = "nicapotato/womens-ecommerce-clothing-reviews" +gold_answer = "the" +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 = "nicapotato__womens-ecommerce-clothing-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nicapotato/womens-ecommerce-clothing-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "the" +QUESTION = "What is the most frequently occurring unigram in the reviews before removing stop words?" +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/0065_794_65794937_qa_5/instruction.md b/tasks/0065_794_65794937_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f49786f1dc060b5f42ce14dcc3da649c968f6a1e --- /dev/null +++ b/tasks/0065_794_65794937_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): +- Tesla.csv - Tesla.csv.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum value in the High price column of 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/0065_794_65794937_qa_5/task.toml b/tasks/0065_794_65794937_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6925078d78bf2789d04f54a3b4c4c968f3637ff5 --- /dev/null +++ b/tasks/0065_794_65794937_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0065_794_65794937_qa_5" +description = "What is the maximum value in the High price column of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/794/65794937.ipynb_qa_5" +kaggle_dataset_name = "rpaguirre/tesla-stock-price" +gold_answer = "291.420013" +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 = "rpaguirre__tesla-stock-price" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rpaguirre/tesla-stock-price" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "291.420013" +QUESTION = "What is the maximum value in the High price column of 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/0066_107_66107048_qa_4/instruction.md b/tasks/0066_107_66107048_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..92b2d4c7adfb3724b18d62aa842fd2d1249ed55f --- /dev/null +++ b/tasks/0066_107_66107048_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): +- archive.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the range of February average temperatures in Pennsylvania when Punxsutawney Phil saw his shadow? + +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/0066_107_66107048_qa_4/task.toml b/tasks/0066_107_66107048_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6eceb75a6cfa03b307db4bf4512ae8a8a2cbe676 --- /dev/null +++ b/tasks/0066_107_66107048_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0066_107_66107048_qa_4" +description = "What is the range of February average temperatures in Pennsylvania when Punxsutawney Phil saw his shadow?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/107/66107048.ipynb_qa_4" +kaggle_dataset_name = "groundhogclub/groundhog-day" +gold_answer = "19.7" +reward_mode_initial = "numeric" +package_tier = 0 +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 = "groundhogclub__groundhog-day" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "groundhogclub/groundhog-day" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "19.7" +QUESTION = "What is the range of February average temperatures in Pennsylvania when Punxsutawney Phil saw his shadow?" +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/0066_186_66186009_qa_3/instruction.md b/tasks/0066_186_66186009_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..628b2c8a12ca94fe7b4369687eb67a5b08d2f6dc --- /dev/null +++ b/tasks/0066_186_66186009_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: +What is the 75th percentile value for the Quantity sold per transaction? + +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/0066_186_66186009_qa_3/task.toml b/tasks/0066_186_66186009_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6fd76b76af58a5ecc5ed7eaba9756b6d6c838178 --- /dev/null +++ b/tasks/0066_186_66186009_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0066_186_66186009_qa_3" +description = "What is the 75th percentile value for the Quantity sold per transaction?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/186/66186009.ipynb_qa_3" +kaggle_dataset_name = "carrie1/ecommerce-data" +gold_answer = "10.0" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "carrie1__ecommerce-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "carrie1/ecommerce-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "10.0" +QUESTION = "What is the 75th percentile value for the Quantity sold per transaction?" +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/0066_186_66186009_qa_4/instruction.md b/tasks/0066_186_66186009_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d7ac4b716e5dd6f5f71322f0a92b87820dbb065f --- /dev/null +++ b/tasks/0066_186_66186009_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 earliest InvoiceDate in the dataset after converting to datetime format? + +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/0066_186_66186009_qa_4/task.toml b/tasks/0066_186_66186009_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b579a1de5de79d2e755faa1dfc3d2c9031eab1a7 --- /dev/null +++ b/tasks/0066_186_66186009_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0066_186_66186009_qa_4" +description = "What is the earliest InvoiceDate in the dataset after converting to datetime format?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/186/66186009.ipynb_qa_4" +kaggle_dataset_name = "carrie1/ecommerce-data" +gold_answer = "2010-12-01 08:26:00" +reward_mode_initial = "exact_short" +package_tier = 3 +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 = "carrie1__ecommerce-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "carrie1/ecommerce-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2010-12-01 08:26:00" +QUESTION = "What is the earliest InvoiceDate in the dataset after converting to datetime format?" +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/0066_372_66372058_qa_4/instruction.md b/tasks/0066_372_66372058_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5f64b0cd2cfa409e733eb06f7c2e771d4c817862 --- /dev/null +++ b/tasks/0066_372_66372058_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): +- credit_train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean value of the `Current Loan Amount` after standardization (z-score normalization)? + +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/0066_372_66372058_qa_4/task.toml b/tasks/0066_372_66372058_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ad9264445bdf49a6109a257bc989a84228230736 --- /dev/null +++ b/tasks/0066_372_66372058_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0066_372_66372058_qa_4" +description = "What is the mean value of the `Current Loan Amount` after standardization (z-score normalization)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/372/66372058.ipynb_qa_4" +kaggle_dataset_name = "zaurbegiev/my-dataset" +gold_answer = "0" +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 = "zaurbegiev__my-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zaurbegiev/my-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "What is the mean value of the `Current Loan Amount` after standardization (z-score normalization)?" +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/0066_429_66429634_qa_5/instruction.md b/tasks/0066_429_66429634_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..82c688d834b4380e3ed59d09a5cea1ff50fff1ec --- /dev/null +++ b/tasks/0066_429_66429634_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which preprocessing step reduced the variance of 'free sulfur dioxide' from 109.414884 to 0.469624? + +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/0066_429_66429634_qa_5/task.toml b/tasks/0066_429_66429634_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dd06d21573193074d20b89af00d5b1ff888054f0 --- /dev/null +++ b/tasks/0066_429_66429634_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0066_429_66429634_qa_5" +description = "Which preprocessing step reduced the variance of 'free sulfur dioxide' from 109.414884 to 0.469624?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/429/66429634.ipynb_qa_5" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "Log transformation" +reward_mode_initial = "exact_short" +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 = "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 = "Log transformation" +QUESTION = "Which preprocessing step reduced the variance of 'free sulfur dioxide' from 109.414884 to 0.469624?" +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/0066_778_66778213_qa_4/instruction.md b/tasks/0066_778_66778213_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fddfcd105d81d9bf80a2e66fda4c150c1707194b --- /dev/null +++ b/tasks/0066_778_66778213_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): +- Automobile_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 fuel system 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/0066_778_66778213_qa_4/task.toml b/tasks/0066_778_66778213_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dbffb2b9c315f2c23e3e2333624f2d4a8ef130c3 --- /dev/null +++ b/tasks/0066_778_66778213_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0066_778_66778213_qa_4" +description = "What is the most common fuel system type in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/778/66778213.ipynb_qa_4" +kaggle_dataset_name = "toramky/automobile-dataset" +gold_answer = "MPFI" +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 = "toramky__automobile-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "toramky/automobile-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "MPFI" +QUESTION = "What is the most common fuel system 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/0067_061_67061270_qa_5/instruction.md b/tasks/0067_061_67061270_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..30bacdb212cfc300faf7cb9faa12dafb6a351525 --- /dev/null +++ b/tasks/0067_061_67061270_qa_5/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): +- matches.csv +- deliveries.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which city hosted the most IPL matches 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/0067_061_67061270_qa_5/task.toml b/tasks/0067_061_67061270_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a1a45917f01953154a0d86d7e8300826403a811f --- /dev/null +++ b/tasks/0067_061_67061270_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0067_061_67061270_qa_5" +description = "Which city hosted the most IPL matches in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/061/67061270.ipynb_qa_5" +kaggle_dataset_name = "manasgarg/ipl" +gold_answer = "Mumbai" +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 = "manasgarg__ipl" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "manasgarg/ipl" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Mumbai" +QUESTION = "Which city hosted the most IPL matches 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/0067_225_67225548_qa_5/instruction.md b/tasks/0067_225_67225548_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..03491d2f792247f12d81cc21f4501a051782a89e --- /dev/null +++ b/tasks/0067_225_67225548_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): +- 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 Spearman correlation coefficient between the number of views a house has and its sale 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/0067_225_67225548_qa_5/task.toml b/tasks/0067_225_67225548_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3ce52181665e12d5f73d9de5f3612ddfd9afee3d --- /dev/null +++ b/tasks/0067_225_67225548_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0067_225_67225548_qa_5" +description = "What is the Spearman correlation coefficient between the number of views a house has and its sale price in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/225/67225548.ipynb_qa_5" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "0.293931" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.293931" +QUESTION = "What is the Spearman correlation coefficient between the number of views a house has and its sale price 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/0067_414_67414974_qa_5/instruction.md b/tasks/0067_414_67414974_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4de2a5622a2fdc946583084803af93b320374e23 --- /dev/null +++ b/tasks/0067_414_67414974_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which education level demonstrates the highest proportion of individuals earning more than $50K according to the dataset's 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/0067_414_67414974_qa_5/task.toml b/tasks/0067_414_67414974_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e42758d77002a0c621a2989089a414d96345fe1a --- /dev/null +++ b/tasks/0067_414_67414974_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0067_414_67414974_qa_5" +description = "Which education level demonstrates the highest proportion of individuals earning more than $50K according to the dataset's analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/414/67414974.ipynb_qa_5" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "Doctorate" +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__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Doctorate" +QUESTION = "Which education level demonstrates the highest proportion of individuals earning more than $50K according to the dataset's analysis?" +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/0067_489_67489322_qa_4/instruction.md b/tasks/0067_489_67489322_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..56d986904fac823d03a68894f35443aba172d292 --- /dev/null +++ b/tasks/0067_489_67489322_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique education categories are present in the dataset after data cleaning? + +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_489_67489322_qa_4/task.toml b/tasks/0067_489_67489322_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..40180cc80c9076b1551e7c6607aed28d312bfa43 --- /dev/null +++ b/tasks/0067_489_67489322_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0067_489_67489322_qa_4" +description = "How many unique education categories are present in the dataset after data cleaning?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/489/67489322.ipynb_qa_4" +kaggle_dataset_name = "wenruliu/adult-income-dataset" +gold_answer = "16" +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 = "wenruliu__adult-income-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wenruliu/adult-income-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "16" +QUESTION = "How many unique education categories are present in the dataset after data cleaning?" +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_607_67607384_qa_1/instruction.md b/tasks/0067_607_67607384_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..70af7a76da8ee679c9547c72f0028f8386aaa212 --- /dev/null +++ b/tasks/0067_607_67607384_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which customer group has the highest churn rate between those with and without a partner? + +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_607_67607384_qa_1/task.toml b/tasks/0067_607_67607384_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cdb11157445a2071f3e7948057d9d0d0d440afe3 --- /dev/null +++ b/tasks/0067_607_67607384_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0067_607_67607384_qa_1" +description = "Which customer group has the highest churn rate between those with and without a partner?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/607/67607384.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "No partner" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "No partner" +QUESTION = "Which customer group has the highest churn rate between those with and without a partner?" +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/0067_657_67657879_qa_3/instruction.md b/tasks/0067_657_67657879_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e2f7c890c1d15dc903995625fffc1098df7cea15 --- /dev/null +++ b/tasks/0067_657_67657879_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean of the total length (Petal Length + Sepal Length) across all samples? + +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_657_67657879_qa_3/task.toml b/tasks/0067_657_67657879_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0f896357588cd62931d46dfac61ddc81fedb4af3 --- /dev/null +++ b/tasks/0067_657_67657879_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0067_657_67657879_qa_3" +description = "What is the mean of the total length (Petal Length + Sepal Length) across all samples?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/657/67657879.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "9.602" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "9.602" +QUESTION = "What is the mean of the total length (Petal Length + Sepal Length) across all samples?" +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/0067_744_67744711_qa_4/instruction.md b/tasks/0067_744_67744711_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ffdf6b6002375416917794c342a1c9414eacffda --- /dev/null +++ b/tasks/0067_744_67744711_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): +- movies.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the strongest positive correlation with gross earnings in the numeric dataset (before categorical encoding)? + +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_744_67744711_qa_4/task.toml b/tasks/0067_744_67744711_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..aa06793d7545b16444b05a91d928a3d7c3fd5e29 --- /dev/null +++ b/tasks/0067_744_67744711_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0067_744_67744711_qa_4" +description = "Which feature has the strongest positive correlation with gross earnings in the numeric dataset (before categorical encoding)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/744/67744711.ipynb_qa_4" +kaggle_dataset_name = "danielgrijalvas/movies" +gold_answer = "Budget" +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 = "danielgrijalvas__movies" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "danielgrijalvas/movies" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Budget" +QUESTION = "Which feature has the strongest positive correlation with gross earnings in the numeric dataset (before categorical encoding)?" +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/0068_405_68405460_qa_4/instruction.md b/tasks/0068_405_68405460_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4c09d8eb0cc783b55ae8ee66878bc13d46a1c31d --- /dev/null +++ b/tasks/0068_405_68405460_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): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct categories are present in the "ocean_proximity" feature? + +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/0068_405_68405460_qa_4/task.toml b/tasks/0068_405_68405460_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9f0e64fc81d30b9051202eca9da3d7e0d46368f0 --- /dev/null +++ b/tasks/0068_405_68405460_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0068_405_68405460_qa_4" +description = "How many distinct categories are present in the \"ocean_proximity\" feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0068/405/68405460.ipynb_qa_4" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "5" +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 = "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 = "How many distinct categories are present in the \"ocean_proximity\" feature?" +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/0068_960_68960212_qa_3/instruction.md b/tasks/0068_960_68960212_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..45f753a826d316e9f11fbfa722a0a32375a6c986 --- /dev/null +++ b/tasks/0068_960_68960212_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): +- archive.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +In the top 5 warmest years according to February average temperature, how many times did Punxsutawney Phil's prediction incorrectly indicate more winter (Full Shadow)? + +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/0068_960_68960212_qa_3/task.toml b/tasks/0068_960_68960212_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..407a41435e250ac14a154fb5cf406ba578a045a2 --- /dev/null +++ b/tasks/0068_960_68960212_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0068_960_68960212_qa_3" +description = "In the top 5 warmest years according to February average temperature, how many times did Punxsutawney Phil's prediction incorrectly indicate more winter (Full Shadow)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0068/960/68960212.ipynb_qa_3" +kaggle_dataset_name = "groundhogclub/groundhog-day" +gold_answer = "5" +reward_mode_initial = "numeric" +package_tier = 0 +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 = "groundhogclub__groundhog-day" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "groundhogclub/groundhog-day" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5" +QUESTION = "In the top 5 warmest years according to February average temperature, how many times did Punxsutawney Phil's prediction incorrectly indicate more winter (Full Shadow)?" +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/0068_960_68960212_qa_4/instruction.md b/tasks/0068_960_68960212_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..103b8591c4756dbf99b0b93f5ad212db263b1cf1 --- /dev/null +++ b/tasks/0068_960_68960212_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): +- archive.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the lowest February average temperature recorded in the dataset for years where Punxsutawney Phil predicted Full Shadow? + +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/0068_960_68960212_qa_4/task.toml b/tasks/0068_960_68960212_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9fab437d3a6cd6f16664d5d1ccc55601036fa6be --- /dev/null +++ b/tasks/0068_960_68960212_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0068_960_68960212_qa_4" +description = "What is the lowest February average temperature recorded in the dataset for years where Punxsutawney Phil predicted Full Shadow?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0068/960/68960212.ipynb_qa_4" +kaggle_dataset_name = "groundhogclub/groundhog-day" +gold_answer = "25.23" +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 = "groundhogclub__groundhog-day" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "groundhogclub/groundhog-day" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "25.23" +QUESTION = "What is the lowest February average temperature recorded in the dataset for years where Punxsutawney Phil predicted Full Shadow?" +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/0069_054_69054524_qa_1/instruction.md b/tasks/0069_054_69054524_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3296cc70ba2e762a17265d3bed8e5ca861b881fa --- /dev/null +++ b/tasks/0069_054_69054524_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which publisher has the highest total global sales 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/0069_054_69054524_qa_1/task.toml b/tasks/0069_054_69054524_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b0898cc6cc434d0c59ad31b9c6802c1158a4ef63 --- /dev/null +++ b/tasks/0069_054_69054524_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0069_054_69054524_qa_1" +description = "Which publisher has the highest total global sales in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0069/054/69054524.ipynb_qa_1" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Nintendo" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Nintendo" +QUESTION = "Which publisher has the highest total global sales 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/0069_548_69548302_qa_1/instruction.md b/tasks/0069_548_69548302_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..32dd2896346a63d8af4d8cb8528c2602bced8003 --- /dev/null +++ b/tasks/0069_548_69548302_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: +Is there a statistically significant difference in medical charges between smokers and non-smokers 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/0069_548_69548302_qa_1/task.toml b/tasks/0069_548_69548302_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..219d51eaf31804bca5e77999b4af7e72b90886c9 --- /dev/null +++ b/tasks/0069_548_69548302_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0069_548_69548302_qa_1" +description = "Is there a statistically significant difference in medical charges between smokers and non-smokers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0069/548/69548302.ipynb_qa_1" +kaggle_dataset_name = "mirichoi0218/insurance" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is there a statistically significant difference in medical charges between smokers and non-smokers in the dataset?" +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_643_69643958_qa_2/instruction.md b/tasks/0069_643_69643958_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3b2ae1bfb278431f1b2ec04614be99422a615645 --- /dev/null +++ b/tasks/0069_643_69643958_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: +Which feature shows the strongest positive correlation with the diabetes outcome variable (Outcome) according to the correlation matrix 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/0069_643_69643958_qa_2/task.toml b/tasks/0069_643_69643958_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a668c744757800a9ac5892bc156fd6c9e24d61f2 --- /dev/null +++ b/tasks/0069_643_69643958_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0069_643_69643958_qa_2" +description = "Which feature shows the strongest positive correlation with the diabetes outcome variable (Outcome) according to the correlation matrix analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0069/643/69643958.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +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__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 = "Which feature shows the strongest positive correlation with the diabetes outcome variable (Outcome) according to the correlation matrix analysis?" +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/0071_543_71543992_qa_2/instruction.md b/tasks/0071_543_71543992_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1e768708798e20bd970749cf474f140117a9eda7 --- /dev/null +++ b/tasks/0071_543_71543992_qa_2/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): +- matches.csv +- deliveries.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of IPL matches ended in a tie 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/0071_543_71543992_qa_2/task.toml b/tasks/0071_543_71543992_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2904bab58db4f02a494b00d2dde48eee8000f16b --- /dev/null +++ b/tasks/0071_543_71543992_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0071_543_71543992_qa_2" +description = "What percentage of IPL matches ended in a tie according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0071/543/71543992.ipynb_qa_2" +kaggle_dataset_name = "manasgarg/ipl" +gold_answer = "1.1" +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 = "manasgarg__ipl" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "manasgarg/ipl" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.1" +QUESTION = "What percentage of IPL matches ended in a tie according to 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/0071_835_71835908_qa_3/instruction.md b/tasks/0071_835_71835908_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f6f83b9e44c4d3427cf6404cc867f8f17e50db2c --- /dev/null +++ b/tasks/0071_835_71835908_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): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What are the four features most strongly correlated with price_range based on the correlation matrix analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact feature names, in the order given. + +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/0071_835_71835908_qa_3/task.toml b/tasks/0071_835_71835908_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..836e826f967dbebc40320f83e2c0da7ad922e069 --- /dev/null +++ b/tasks/0071_835_71835908_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0071_835_71835908_qa_3" +description = "What are the four features most strongly correlated with price_range based on the correlation matrix analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0071/835/71835908.ipynb_qa_3" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "ram, battery_power, px_width, px_height" +reward_mode_initial = "list" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "ram, battery_power, px_width, px_height" +QUESTION = "What are the four features most strongly correlated with price_range based on the correlation matrix analysis?" +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/0072_071_72071082_qa_5/instruction.md b/tasks/0072_071_72071082_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..82882ec83c6f68fbaa84d2aafa1712d2b1b3f8f8 --- /dev/null +++ b/tasks/0072_071_72071082_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): +- Automobile_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which fuel type is most common in the dataset based on the value counts 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/0072_071_72071082_qa_5/task.toml b/tasks/0072_071_72071082_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..af226e14dfe26c9b5e50578e3a009642211b45fe --- /dev/null +++ b/tasks/0072_071_72071082_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0072_071_72071082_qa_5" +description = "Which fuel type is most common in the dataset based on the value counts analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0072/071/72071082.ipynb_qa_5" +kaggle_dataset_name = "toramky/automobile-dataset" +gold_answer = "gas" +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 = "toramky__automobile-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "toramky/automobile-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "gas" +QUESTION = "Which fuel type is most common in the dataset based on the value counts analysis?" +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/0072_471_72471518_qa_3/instruction.md b/tasks/0072_471_72471518_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8e44403b333a3fea9602e6383a456d6ba3f446e6 --- /dev/null +++ b/tasks/0072_471_72471518_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After applying the square root transformation, what was the skewness value of the TotalCharges column? + +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/0072_471_72471518_qa_3/task.toml b/tasks/0072_471_72471518_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..197d3b3e13b1e091110327d8717643e0e286f84d --- /dev/null +++ b/tasks/0072_471_72471518_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0072_471_72471518_qa_3" +description = "After applying the square root transformation, what was the skewness value of the TotalCharges column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0072/471/72471518.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "0.3089" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.3089" +QUESTION = "After applying the square root transformation, what was the skewness value of the TotalCharges column?" +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/0072_789_72789077_qa_4/instruction.md b/tasks/0072_789_72789077_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..843b5f7cdcc340990229b247343835bfa001723a --- /dev/null +++ b/tasks/0072_789_72789077_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average area population across all samples 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/0072_789_72789077_qa_4/task.toml b/tasks/0072_789_72789077_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..886f864305b8b4e50cf473cf88bba4f5e12d2a06 --- /dev/null +++ b/tasks/0072_789_72789077_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0072_789_72789077_qa_4" +description = "What is the average area population across all samples in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0072/789/72789077.ipynb_qa_4" +kaggle_dataset_name = "vedavyasv/usa-housing" +gold_answer = "36163.516" +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 = "vedavyasv__usa-housing" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vedavyasv/usa-housing" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "36163.516" +QUESTION = "What is the average area population across all samples 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/0072_839_72839930_qa_3/instruction.md b/tasks/0072_839_72839930_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3af92f1445892929bff3c876db6ca372d80b92a9 --- /dev/null +++ b/tasks/0072_839_72839930_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: +Which cluster count yields the lowest Davies-Bouldin Score in the clustering evaluation? + +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/0072_839_72839930_qa_3/task.toml b/tasks/0072_839_72839930_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..28dd69a23e711804bf36db178650e9eb2641796d --- /dev/null +++ b/tasks/0072_839_72839930_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0072_839_72839930_qa_3" +description = "Which cluster count yields the lowest Davies-Bouldin Score in the clustering evaluation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0072/839/72839930.ipynb_qa_3" +kaggle_dataset_name = "uciml/mushroom-classification" +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__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "Which cluster count yields the lowest Davies-Bouldin Score in the clustering 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/0073_439_73439547_qa_3/instruction.md b/tasks/0073_439_73439547_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a1df9aebd86cd7e699a0acee2a1393a3e0d7cdc7 --- /dev/null +++ b/tasks/0073_439_73439547_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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many duplicate records were removed during data preprocessing? + +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/0073_439_73439547_qa_3/task.toml b/tasks/0073_439_73439547_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..03ac5ed380577e104367d60542583280e42ac897 --- /dev/null +++ b/tasks/0073_439_73439547_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0073_439_73439547_qa_3" +description = "How many duplicate records were removed during data preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0073/439/73439547.ipynb_qa_3" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "240" +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 = "240" +QUESTION = "How many duplicate records were removed during data preprocessing?" +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/0073_529_73529560_qa_5/instruction.md b/tasks/0073_529_73529560_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..58f43bee2dfaa06c3468c5fd067fb3523eae8a60 --- /dev/null +++ b/tasks/0073_529_73529560_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): +- indian_liver_patient.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the proportion of unhealthy liver patients (class 0) compared to healthy patients (class 1) in the original dataset before oversampling? + +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/0073_529_73529560_qa_5/task.toml b/tasks/0073_529_73529560_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fb9f5bbec7b366132cf03bd5e634e14d94e07bff --- /dev/null +++ b/tasks/0073_529_73529560_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0073_529_73529560_qa_5" +description = "What was the proportion of unhealthy liver patients (class 0) compared to healthy patients (class 1) in the original dataset before oversampling?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0073/529/73529560.ipynb_qa_5" +kaggle_dataset_name = "uciml/indian-liver-patient-records" +gold_answer = "2.5:1" +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__indian-liver-patient-records" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/indian-liver-patient-records" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2.5:1" +QUESTION = "What was the proportion of unhealthy liver patients (class 0) compared to healthy patients (class 1) in the original dataset before oversampling?" +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/0073_719_73719424_qa_1/instruction.md b/tasks/0073_719_73719424_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..aff306e272fe01632dd977bf614ab450a916e488 --- /dev/null +++ b/tasks/0073_719_73719424_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): +- WA_Fn-UseC_-Telco-Customer-Churn.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 TotalCharges column before they were removed from 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/0073_719_73719424_qa_1/task.toml b/tasks/0073_719_73719424_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b77f8995815c1a8d567aa78a0c8562a4599a13dc --- /dev/null +++ b/tasks/0073_719_73719424_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0073_719_73719424_qa_1" +description = "How many missing values were present in the TotalCharges column before they were removed from the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0073/719/73719424.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "11" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11" +QUESTION = "How many missing values were present in the TotalCharges column before they were removed from 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/0074_013_74013118_qa_3/instruction.md b/tasks/0074_013_74013118_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d1566878641673c65797d6889844206d01a88e60 --- /dev/null +++ b/tasks/0074_013_74013118_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): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After stratified sampling, how many districts are in the test set, and what is the proportion of income category 3 in the test set? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, count first, proportion as a plain number with six decimals). + +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/0074_013_74013118_qa_3/task.toml b/tasks/0074_013_74013118_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cd61272946bd1210f5ba3725f6dd79a882c94a67 --- /dev/null +++ b/tasks/0074_013_74013118_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0074_013_74013118_qa_3" +description = "After stratified sampling, how many districts are in the test set, and what is the proportion of income category 3 in the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/013/74013118.ipynb_qa_3" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "4128, 0.350533" +reward_mode_initial = "list" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4128, 0.350533" +QUESTION = "After stratified sampling, how many districts are in the test set, and what is the proportion of income category 3 in the test set?" +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/0074_514_74514325_qa_1/instruction.md b/tasks/0074_514_74514325_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cb7185bc08b40485f74f66090ec094a8c52e6778 --- /dev/null +++ b/tasks/0074_514_74514325_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: +What is the correlation coefficient between height and weight 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/0074_514_74514325_qa_1/task.toml b/tasks/0074_514_74514325_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d660b5d92f534e017a197df95fc300202ecdd31f --- /dev/null +++ b/tasks/0074_514_74514325_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0074_514_74514325_qa_1" +description = "What is the correlation coefficient between height and weight in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/514/74514325.ipynb_qa_1" +kaggle_dataset_name = "tmcketterick/heights-and-weights" +gold_answer = "0.994584" +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 = "tmcketterick__heights-and-weights" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "tmcketterick/heights-and-weights" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.994584" +QUESTION = "What is the correlation coefficient between height and weight 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/0074_549_74549731_qa_2/instruction.md b/tasks/0074_549_74549731_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..61335b356b58cc756384b2da3dd2510d7a1f9f4e --- /dev/null +++ b/tasks/0074_549_74549731_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): +- survey.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many respondents completed the survey in the year 2016? + +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/0074_549_74549731_qa_2/task.toml b/tasks/0074_549_74549731_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f96797b680dfcf9b0fd07d185f854e6175d8ef73 --- /dev/null +++ b/tasks/0074_549_74549731_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0074_549_74549731_qa_2" +description = "How many respondents completed the survey in the year 2016?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/549/74549731.ipynb_qa_2" +kaggle_dataset_name = "osmi/mental-health-in-tech-survey" +gold_answer = "1" +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 = "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 = "1" +QUESTION = "How many respondents completed the survey in the year 2016?" +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/0074_549_74549731_qa_5/instruction.md b/tasks/0074_549_74549731_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..83a7223df52213bd9c4e1640ed1f5f3da006ba73 --- /dev/null +++ b/tasks/0074_549_74549731_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): +- survey.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After data cleaning, how many respondents answered `Yes` to seeking help for mental health issues? + +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/0074_549_74549731_qa_5/task.toml b/tasks/0074_549_74549731_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..89ef0afc6de722292ebd830d2dad9711255a250a --- /dev/null +++ b/tasks/0074_549_74549731_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0074_549_74549731_qa_5" +description = "After data cleaning, how many respondents answered `Yes` to seeking help for mental health issues?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/549/74549731.ipynb_qa_5" +kaggle_dataset_name = "osmi/mental-health-in-tech-survey" +gold_answer = "250" +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 = "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 = "250" +QUESTION = "After data cleaning, how many respondents answered `Yes` to seeking help for mental health issues?" +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/0074_776_74776615_qa_1/instruction.md b/tasks/0074_776_74776615_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..131e87d9c47d6be7b4cf959d2ef572c687ce9c25 --- /dev/null +++ b/tasks/0074_776_74776615_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): +- Telecom_customer churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of customers who churned in the dataset before handling 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/0074_776_74776615_qa_1/task.toml b/tasks/0074_776_74776615_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e531f884a551894fd774fff2d2dccf05111c2ead --- /dev/null +++ b/tasks/0074_776_74776615_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0074_776_74776615_qa_1" +description = "What is the percentage of customers who churned in the dataset before handling missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/776/74776615.ipynb_qa_1" +kaggle_dataset_name = "abhinav89/telecom-customer" +gold_answer = "49.3" +reward_mode_initial = "numeric" +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 = "abhinav89__telecom-customer" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abhinav89/telecom-customer" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "49.3" +QUESTION = "What is the percentage of customers who churned in the dataset before handling missing values?" +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/0075_094_75094397_qa_1/instruction.md b/tasks/0075_094_75094397_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..68e434b636974c80c5d0e7ce7527a4c05cb4927d --- /dev/null +++ b/tasks/0075_094_75094397_qa_1/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): +- Train.csv +- Test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the 'Item_Weight' column contained missing values before imputation? + +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_094_75094397_qa_1/task.toml b/tasks/0075_094_75094397_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..12fad207987b57360807449f0e4a5c13045aa101 --- /dev/null +++ b/tasks/0075_094_75094397_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0075_094_75094397_qa_1" +description = "What percentage of the 'Item_Weight' column contained missing values before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/094/75094397.ipynb_qa_1" +kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data" +gold_answer = "17.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 = "brijbhushannanda1979__bigmart-sales-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "17.17" +QUESTION = "What percentage of the 'Item_Weight' column contained missing values before imputation?" +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/0075_379_75379398_qa_2/instruction.md b/tasks/0075_379_75379398_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1a65eddfc6f389a0c6d4d2eb6715382d580c513f --- /dev/null +++ b/tasks/0075_379_75379398_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): +- Suicides in India 2001-2012.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which age group had the highest total recorded suicide cases during the 12-year period analyzed? + +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_379_75379398_qa_2/task.toml b/tasks/0075_379_75379398_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..37c27c95677c215e25f3b40c2fdecd50d6a76ba9 --- /dev/null +++ b/tasks/0075_379_75379398_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0075_379_75379398_qa_2" +description = "Which age group had the highest total recorded suicide cases during the 12-year period analyzed?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/379/75379398.ipynb_qa_2" +kaggle_dataset_name = "rajanand/suicides-in-india" +gold_answer = "15-29" +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 = "rajanand__suicides-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/suicides-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "15-29" +QUESTION = "Which age group had the highest total recorded suicide cases during the 12-year period analyzed?" +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_391_75391350_qa_3/instruction.md b/tasks/0075_391_75391350_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8f2dddf197a2d88b131454a675c9b95dbd8eb82d --- /dev/null +++ b/tasks/0075_391_75391350_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): +- movies_metadata.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which movie has the highest overall score in the top-rated list? + +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_391_75391350_qa_3/task.toml b/tasks/0075_391_75391350_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3ad89634b891db64e055186f1f656ff66cceb6eb --- /dev/null +++ b/tasks/0075_391_75391350_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0075_391_75391350_qa_3" +description = "Which movie has the highest overall score in the top-rated list?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/391/75391350.ipynb_qa_3" +kaggle_dataset_name = "rounakbanik/the-movies-dataset" +gold_answer = "The Shawshank Redemption" +reward_mode_initial = "exact_short" +package_tier = 0 +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 = "rounakbanik__the-movies-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rounakbanik/the-movies-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "The Shawshank Redemption" +QUESTION = "Which movie has the highest overall score in the top-rated list?" +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_890_75890673_qa_3/instruction.md b/tasks/0075_890_75890673_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ef5dd01a7f5e447aa7187807c11ce05075cd25d3 --- /dev/null +++ b/tasks/0075_890_75890673_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the validation set predictions were true negatives according to the confusion matrix in percentage form? + +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_890_75890673_qa_3/task.toml b/tasks/0075_890_75890673_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8c54cbbd9d19d2a7afcfee6b57d620f361d23724 --- /dev/null +++ b/tasks/0075_890_75890673_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0075_890_75890673_qa_3" +description = "What percentage of the validation set predictions were true negatives according to the confusion matrix in percentage form?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/890/75890673.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "65" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "65" +QUESTION = "What percentage of the validation set predictions were true negatives according to the confusion matrix in percentage form?" +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/0075_890_75890673_qa_4/instruction.md b/tasks/0075_890_75890673_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bbd1550ecaf9211113a0cb60238796043d989058 --- /dev/null +++ b/tasks/0075_890_75890673_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the proportion of churned customers in the full dataset (before train/validation/test split)? + +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_890_75890673_qa_4/task.toml b/tasks/0075_890_75890673_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..930acdde900744d4c9847ec0a888c26e52dbabbb --- /dev/null +++ b/tasks/0075_890_75890673_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0075_890_75890673_qa_4" +description = "What is the proportion of churned customers in the full dataset (before train/validation/test split)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/890/75890673.ipynb_qa_4" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "26.54" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "26.54" +QUESTION = "What is the proportion of churned customers in the full dataset (before train/validation/test split)?" +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/0077_100_77100984_qa_2/instruction.md b/tasks/0077_100_77100984_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8a4986a2fb8606abbbabddee5f1a550fe9ee72ca --- /dev/null +++ b/tasks/0077_100_77100984_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What are the median insulin levels for non-diabetic and diabetic individuals in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list: , (plain numbers, in that 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/0077_100_77100984_qa_2/task.toml b/tasks/0077_100_77100984_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0dcc1e2cc927c78f681b45aee700d8a548ea7f87 --- /dev/null +++ b/tasks/0077_100_77100984_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0077_100_77100984_qa_2" +description = "What are the median insulin levels for non-diabetic and diabetic individuals in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/100/77100984.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "102.5, 169.5" +reward_mode_initial = "list" +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 = "102.5, 169.5" +QUESTION = "What are the median insulin levels for non-diabetic and diabetic individuals in the dataset?" +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/0077_529_77529364_qa_3/instruction.md b/tasks/0077_529_77529364_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..69a8e4987f4f1fdcdfcb0e3550521b1c7c6ff4f4 --- /dev/null +++ b/tasks/0077_529_77529364_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: +Among the tested models (SVM with different kernels and KNN), which achieved the highest accuracy 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/0077_529_77529364_qa_3/task.toml b/tasks/0077_529_77529364_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b0758439554f988e117764eac019fc50c7f715d1 --- /dev/null +++ b/tasks/0077_529_77529364_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0077_529_77529364_qa_3" +description = "Among the tested models (SVM with different kernels and KNN), which achieved the highest accuracy on the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/529/77529364.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Linear SVM" +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 = "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 = "Linear SVM" +QUESTION = "Among the tested models (SVM with different kernels and KNN), which achieved the highest accuracy on the test set?" +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/0077_578_77578267_qa_4/instruction.md b/tasks/0077_578_77578267_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..60502d419d995f4dc3947ba2107080b853e6d9e4 --- /dev/null +++ b/tasks/0077_578_77578267_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the total global sales contribution from games released in the year 2000? + +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_578_77578267_qa_4/task.toml b/tasks/0077_578_77578267_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..10fd7d22af7fc4c6caafa26a77bafd2421e669fc --- /dev/null +++ b/tasks/0077_578_77578267_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0077_578_77578267_qa_4" +description = "What was the total global sales contribution from games released in the year 2000?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/578/77578267.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "201.56" +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 = "201.56" +QUESTION = "What was the total global sales contribution from games released in the year 2000?" +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/0077_684_77684454_qa_2/instruction.md b/tasks/0077_684_77684454_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f66d4f9e5b68502618de4478aaea7b532ce667d0 --- /dev/null +++ b/tasks/0077_684_77684454_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): +- archive.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of Nobel Prize laureates classified as 'Senior' in the Age_Group feature (age 65+)? + +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_684_77684454_qa_2/task.toml b/tasks/0077_684_77684454_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c4d3648df698eb2c9e307c614104dbd4b8259f24 --- /dev/null +++ b/tasks/0077_684_77684454_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0077_684_77684454_qa_2" +description = "What is the percentage of Nobel Prize laureates classified as 'Senior' in the Age_Group feature (age 65+)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/684/77684454.ipynb_qa_2" +kaggle_dataset_name = "nobelfoundation/nobel-laureates" +gold_answer = "34.22" +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 = "nobelfoundation__nobel-laureates" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nobelfoundation/nobel-laureates" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "34.22" +QUESTION = "What is the percentage of Nobel Prize laureates classified as 'Senior' in the Age_Group feature (age 65+)?" +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/0077_684_77684454_qa_5/instruction.md b/tasks/0077_684_77684454_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ceaa7e64e86ccb9f77a0cff3cb3b93d47feb7780 --- /dev/null +++ b/tasks/0077_684_77684454_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): +- archive.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of Nobel Prize laureates in the 'Adult' age group (30-64 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/0077_684_77684454_qa_5/task.toml b/tasks/0077_684_77684454_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2e8edeb7ccf6b175f03fa3758f33d3cd15c2b429 --- /dev/null +++ b/tasks/0077_684_77684454_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0077_684_77684454_qa_5" +description = "What is the percentage of Nobel Prize laureates in the 'Adult' age group (30-64 years)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/684/77684454.ipynb_qa_5" +kaggle_dataset_name = "nobelfoundation/nobel-laureates" +gold_answer = "65.57" +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 = "nobelfoundation__nobel-laureates" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nobelfoundation/nobel-laureates" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "65.57" +QUESTION = "What is the percentage of Nobel Prize laureates in the 'Adult' age group (30-64 years)?" +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/0077_800_77800758_qa_5/instruction.md b/tasks/0077_800_77800758_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5ff8705cb6d066a32cd5e7dad72b336d2cde8052 --- /dev/null +++ b/tasks/0077_800_77800758_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 difference in average Glucose levels between diabetic and non-diabetic individuals? + +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_800_77800758_qa_5/task.toml b/tasks/0077_800_77800758_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..37b48ee3bb943f6bbcfb64ca52aee0077a1fd75d --- /dev/null +++ b/tasks/0077_800_77800758_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0077_800_77800758_qa_5" +description = "What is the difference in average Glucose levels between diabetic and non-diabetic individuals?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/800/77800758.ipynb_qa_5" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "31.28" +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 = "31.28" +QUESTION = "What is the difference in average Glucose levels between diabetic and non-diabetic individuals?" +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/0079_455_79455690_qa_1/instruction.md b/tasks/0079_455_79455690_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..110b47f0fe281980fdc99251c6afc83439d867fa --- /dev/null +++ b/tasks/0079_455_79455690_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: +How many products are categorized as "Low Fat" after correcting the inconsistencies in the Item_Fat_Content column? + +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/0079_455_79455690_qa_1/task.toml b/tasks/0079_455_79455690_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e218f53f2502d70fe058ae1c44ca69973b78bf5f --- /dev/null +++ b/tasks/0079_455_79455690_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0079_455_79455690_qa_1" +description = "How many products are categorized as \"Low Fat\" after correcting the inconsistencies in the Item_Fat_Content column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0079/455/79455690.ipynb_qa_1" +kaggle_dataset_name = "devashish0507/big-mart-sales-prediction" +gold_answer = "5517" +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 = "devashish0507__big-mart-sales-prediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "devashish0507/big-mart-sales-prediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5517" +QUESTION = "How many products are categorized as \"Low Fat\" after correcting the inconsistencies in the Item_Fat_Content column?" +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/0079_597_79597687_qa_2/instruction.md b/tasks/0079_597_79597687_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..685128f177d80b057c1af14a74cd5d93d459e0d9 --- /dev/null +++ b/tasks/0079_597_79597687_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 optimal number of neighbors (k) selected by grid search for the KNN model based on 10-fold cross-validation? + +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/0079_597_79597687_qa_2/task.toml b/tasks/0079_597_79597687_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5983a0912b7fa397116335b31332bf3fa1bb9438 --- /dev/null +++ b/tasks/0079_597_79597687_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0079_597_79597687_qa_2" +description = "What is the optimal number of neighbors (k) selected by grid search for the KNN model based on 10-fold cross-validation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0079/597/79597687.ipynb_qa_2" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "5" +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 = "5" +QUESTION = "What is the optimal number of neighbors (k) selected by grid search for the KNN model based on 10-fold cross-validation?" +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/0079_597_79597687_qa_5/instruction.md b/tasks/0079_597_79597687_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3f54169333bcb5d161ec11e05fb2a215bb0bed6a --- /dev/null +++ b/tasks/0079_597_79597687_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): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean squared error (MSE) on the test set for the tuned KNN model with optimal parameters? + +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/0079_597_79597687_qa_5/task.toml b/tasks/0079_597_79597687_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e505cf7ac19178a51aece3b211358088e8207893 --- /dev/null +++ b/tasks/0079_597_79597687_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0079_597_79597687_qa_5" +description = "What is the mean squared error (MSE) on the test set for the tuned KNN model with optimal parameters?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0079/597/79597687.ipynb_qa_5" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.05" +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 = "0.05" +QUESTION = "What is the mean squared error (MSE) on the test set for the tuned KNN model with optimal parameters?" +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/0079_852_79852470_qa_3/instruction.md b/tasks/0079_852_79852470_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..184ce8367a6287445890581af90e6ed02b1683c7 --- /dev/null +++ b/tasks/0079_852_79852470_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After cleaning the dataset, how many rows remain in the dataset following the removal of missing values from the "Publisher" column? + +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/0079_852_79852470_qa_3/task.toml b/tasks/0079_852_79852470_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..524aa2e0c8e2e459a531563d1922244dfabc24c9 --- /dev/null +++ b/tasks/0079_852_79852470_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0079_852_79852470_qa_3" +description = "After cleaning the dataset, how many rows remain in the dataset following the removal of missing values from the \"Publisher\" column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0079/852/79852470.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "16540" +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 = "16540" +QUESTION = "After cleaning the dataset, how many rows remain in the dataset following the removal of missing values from the \"Publisher\" column?" +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/0079_852_79852470_qa_4/instruction.md b/tasks/0079_852_79852470_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cd2c1fd9da321ad3e41f6a78541d9253bc120f99 --- /dev/null +++ b/tasks/0079_852_79852470_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median year value calculated for imputing missing values in the "Year" column before converting it to an integer type? + +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/0079_852_79852470_qa_4/task.toml b/tasks/0079_852_79852470_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fc4712a1b30e7adcb2108a86931bec4cda85ced6 --- /dev/null +++ b/tasks/0079_852_79852470_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0079_852_79852470_qa_4" +description = "What is the median year value calculated for imputing missing values in the \"Year\" column before converting it to an integer type?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0079/852/79852470.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "2007" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2007" +QUESTION = "What is the median year value calculated for imputing missing values in the \"Year\" column before converting it to an integer type?" +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/0080_011_80011409_qa_3/instruction.md b/tasks/0080_011_80011409_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ba81b39a77c1b2e43fd358efd48aaf1ecfda3af6 --- /dev/null +++ b/tasks/0080_011_80011409_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the range of PetalWidthCm 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/0080_011_80011409_qa_3/task.toml b/tasks/0080_011_80011409_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..60e666deb1ad876a2ea34154f0cc612f060caedc --- /dev/null +++ b/tasks/0080_011_80011409_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0080_011_80011409_qa_3" +description = "What is the range of PetalWidthCm in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0080/011/80011409.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "2.4" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2.4" +QUESTION = "What is the range of PetalWidthCm 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/0080_011_80011409_qa_4/instruction.md b/tasks/0080_011_80011409_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ddc6268567de685d793e063655b9d28c1e32ff34 --- /dev/null +++ b/tasks/0080_011_80011409_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the lowest 75th percentile value 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/0080_011_80011409_qa_4/task.toml b/tasks/0080_011_80011409_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f7ee4bbf87c89886781e7a68bbf8f575c33a5edb --- /dev/null +++ b/tasks/0080_011_80011409_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0080_011_80011409_qa_4" +description = "Which feature has the lowest 75th percentile value in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0080/011/80011409.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalWidthCm" +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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PetalWidthCm" +QUESTION = "Which feature has the lowest 75th percentile value 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/0080_200_80200515_qa_3/instruction.md b/tasks/0080_200_80200515_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..66dfc1cfd7c1fbbcd01180fde3f40df090771965 --- /dev/null +++ b/tasks/0080_200_80200515_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: +Which numerical feature shows the highest positive correlation with the 'loudness' feature? + +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/0080_200_80200515_qa_3/task.toml b/tasks/0080_200_80200515_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0208d74334b4ffc17df8f220e490c1a5f76a4d43 --- /dev/null +++ b/tasks/0080_200_80200515_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0080_200_80200515_qa_3" +description = "Which numerical feature shows the highest positive correlation with the 'loudness' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0080/200/80200515.ipynb_qa_3" +kaggle_dataset_name = "geomack/spotifyclassification" +gold_answer = "Energy" +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 = "geomack__spotifyclassification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "geomack/spotifyclassification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Energy" +QUESTION = "Which numerical feature shows the highest positive correlation with the 'loudness' feature?" +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/0081_332_81332828_qa_5/instruction.md b/tasks/0081_332_81332828_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..da09cbe2ecf3b30c3339f18adcf47716cfcb812f --- /dev/null +++ b/tasks/0081_332_81332828_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): +- HousingData.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature exhibits the strongest negative correlation with the median home value (MEDV) in the Boston housing 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/0081_332_81332828_qa_5/task.toml b/tasks/0081_332_81332828_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..aabcabe5736952836cf96de6f3eeae91b67b4676 --- /dev/null +++ b/tasks/0081_332_81332828_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0081_332_81332828_qa_5" +description = "Which feature exhibits the strongest negative correlation with the median home value (MEDV) in the Boston housing dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0081/332/81332828.ipynb_qa_5" +kaggle_dataset_name = "altavish/boston-housing-dataset" +gold_answer = "LSTAT" +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 = "altavish__boston-housing-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "altavish/boston-housing-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "LSTAT" +QUESTION = "Which feature exhibits the strongest negative correlation with the median home value (MEDV) in the Boston housing 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/0081_468_81468620_qa_4/instruction.md b/tasks/0081_468_81468620_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ca03688b003cdf5714c879e62c2390962e48fcfd --- /dev/null +++ b/tasks/0081_468_81468620_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which video game genre has the highest sales revenue in Japan? + +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/0081_468_81468620_qa_4/task.toml b/tasks/0081_468_81468620_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bc0a8815cb2858f34af6229aa18cd60075581954 --- /dev/null +++ b/tasks/0081_468_81468620_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0081_468_81468620_qa_4" +description = "Which video game genre has the highest sales revenue in Japan?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0081/468/81468620.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Role-Playing" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Role-Playing" +QUESTION = "Which video game genre has the highest sales revenue in Japan?" +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/0081_701_81701476_qa_3/instruction.md b/tasks/0081_701_81701476_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b616b6ef3fb9908a3542246bbfcfd2db7b696594 --- /dev/null +++ b/tasks/0081_701_81701476_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the skewness value for the Sepal Width feature 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/0081_701_81701476_qa_3/task.toml b/tasks/0081_701_81701476_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..65ff84e48e7b2f91af5a35e822111f2029795c8a --- /dev/null +++ b/tasks/0081_701_81701476_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0081_701_81701476_qa_3" +description = "What is the skewness value for the Sepal Width feature in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0081/701/81701476.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.334053" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.334053" +QUESTION = "What is the skewness value for the Sepal Width feature 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/0083_191_83191425_qa_3/instruction.md b/tasks/0083_191_83191425_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..173cce25dbfd4734879a70ddf8820923d2fa1cfa --- /dev/null +++ b/tasks/0083_191_83191425_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): +- Mall_Customers.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the silhouette score for the K-Means clustering model when k=5? + +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/0083_191_83191425_qa_3/task.toml b/tasks/0083_191_83191425_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0b3ea347e31e4177841c0ebb6779d8de7951263d --- /dev/null +++ b/tasks/0083_191_83191425_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0083_191_83191425_qa_3" +description = "What is the silhouette score for the K-Means clustering model when k=5?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0083/191/83191425.ipynb_qa_3" +kaggle_dataset_name = "shwetabh123/mall-customers" +gold_answer = "0.553931997444648" +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 = "shwetabh123__mall-customers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shwetabh123/mall-customers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.553931997444648" +QUESTION = "What is the silhouette score for the K-Means clustering model when k=5?" +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_238_83238182_qa_2/instruction.md b/tasks/0083_238_83238182_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a00200cf54e28b518a93c8a05d36f32d3a7a9c86 --- /dev/null +++ b/tasks/0083_238_83238182_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): +- UCI_Credit_Card.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 two features 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/0083_238_83238182_qa_2/task.toml b/tasks/0083_238_83238182_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..da63fc4503a365e1b921c9678d343b5d353ecfb6 --- /dev/null +++ b/tasks/0083_238_83238182_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0083_238_83238182_qa_2" +description = "What is the highest correlation coefficient between any two features in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0083/238/83238182.ipynb_qa_2" +kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset" +gold_answer = "1.00" +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__default-of-credit-card-clients-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/default-of-credit-card-clients-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.00" +QUESTION = "What is the highest correlation coefficient between any two features 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/0084_320_84320235_qa_1/instruction.md b/tasks/0084_320_84320235_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5ed3c6341a107eb6ed513e0f2af7fd19928dc99f --- /dev/null +++ b/tasks/0084_320_84320235_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): +- Salary_Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the final optimized cost after performing gradient descent on 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/0084_320_84320235_qa_1/task.toml b/tasks/0084_320_84320235_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7fd3a69d21db167cceac78429139de800aff21af --- /dev/null +++ b/tasks/0084_320_84320235_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0084_320_84320235_qa_1" +description = "What is the final optimized cost after performing gradient descent on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/320/84320235.ipynb_qa_1" +kaggle_dataset_name = "karthickveerakumar/salary-data-simple-linear-regression" +gold_answer = "15742742.122957915" +reward_mode_initial = "numeric" +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 = "karthickveerakumar__salary-data-simple-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "karthickveerakumar/salary-data-simple-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "15742742.122957915" +QUESTION = "What is the final optimized cost after performing gradient descent on the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +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/0084_737_84737869_qa_2/instruction.md b/tasks/0084_737_84737869_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d3a0c59913ac3575a42a63efe96147ebbd12155e --- /dev/null +++ b/tasks/0084_737_84737869_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which two features were identified as the most significant predictors of diabetes outcome using the ANOVA (f_classif) feature selection method? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact feature names. + +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_737_84737869_qa_2/task.toml b/tasks/0084_737_84737869_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9938faf5bb8febb1831a080ea4bd0fcf9400a310 --- /dev/null +++ b/tasks/0084_737_84737869_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0084_737_84737869_qa_2" +description = "Which two features were identified as the most significant predictors of diabetes outcome using the ANOVA (f_classif) feature selection method?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/737/84737869.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose, BMI" +reward_mode_initial = "list" +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 = "Glucose, BMI" +QUESTION = "Which two features were identified as the most significant predictors of diabetes outcome using the ANOVA (f_classif) feature selection method?" +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/0084_979_84979426_qa_5/instruction.md b/tasks/0084_979_84979426_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..16c995a6d8b3d6ba665ff0c2dc42782284e3d59e --- /dev/null +++ b/tasks/0084_979_84979426_qa_5/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): +- kiva_mpi_region_locations.csv +- loan_themes_by_region.csv +- kiva_loans.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What repayment interval type is associated with the highest total loan amount in Brazil's 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/0084_979_84979426_qa_5/task.toml b/tasks/0084_979_84979426_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..61adccae17c911b7b7e55b97e9ef25a0daa15cf2 --- /dev/null +++ b/tasks/0084_979_84979426_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0084_979_84979426_qa_5" +description = "What repayment interval type is associated with the highest total loan amount in Brazil's dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/979/84979426.ipynb_qa_5" +kaggle_dataset_name = "kiva/data-science-for-good-kiva-crowdfunding" +gold_answer = "Irregular" +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 = "kiva__data-science-for-good-kiva-crowdfunding" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kiva/data-science-for-good-kiva-crowdfunding" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Irregular" +QUESTION = "What repayment interval type is associated with the highest total loan amount in Brazil's 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/0085_343_85343577_qa_3/instruction.md b/tasks/0085_343_85343577_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b3db82269681f42ce498d161a9d0cf3537420c53 --- /dev/null +++ b/tasks/0085_343_85343577_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): +- sudoku.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct Sudoku puzzles are contained in the training 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/0085_343_85343577_qa_3/task.toml b/tasks/0085_343_85343577_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a0e4502501e28e9d651e231e5d9c8b3da7462f71 --- /dev/null +++ b/tasks/0085_343_85343577_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0085_343_85343577_qa_3" +description = "How many distinct Sudoku puzzles are contained in the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0085/343/85343577.ipynb_qa_3" +kaggle_dataset_name = "bryanpark/sudoku" +gold_answer = "1000000" +reward_mode_initial = "numeric" +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 = "bryanpark__sudoku" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "bryanpark/sudoku" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1000000" +QUESTION = "How many distinct Sudoku puzzles are contained in the training 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/0085_804_85804318_qa_3/instruction.md b/tasks/0085_804_85804318_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..035ccb7529fc8b255a2f2e9fdd29160c738c0d10 --- /dev/null +++ b/tasks/0085_804_85804318_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): +- Train.csv +- Test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common outlet size 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/0085_804_85804318_qa_3/task.toml b/tasks/0085_804_85804318_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ef02c5a2522053c6e5a76bcbda14bac6343a3d93 --- /dev/null +++ b/tasks/0085_804_85804318_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0085_804_85804318_qa_3" +description = "What is the most common outlet size in the training data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0085/804/85804318.ipynb_qa_3" +kaggle_dataset_name = "devashish0507/big-mart-sales-prediction" +gold_answer = "Medium" +reward_mode_initial = "exact_short" +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 = "devashish0507__big-mart-sales-prediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "devashish0507/big-mart-sales-prediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Medium" +QUESTION = "What is the most common outlet size in the training data?" +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/0085_903_85903605_qa_3/instruction.md b/tasks/0085_903_85903605_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bb76916064c9eae3860c628d7700a58d1ad4f65f --- /dev/null +++ b/tasks/0085_903_85903605_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): +- tmdb_5000_movies.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median popularity score across all movies 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/0085_903_85903605_qa_3/task.toml b/tasks/0085_903_85903605_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..802c076bfd4d974722504392debf78098931e0f4 --- /dev/null +++ b/tasks/0085_903_85903605_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0085_903_85903605_qa_3" +description = "What is the median popularity score across all movies in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0085/903/85903605.ipynb_qa_3" +kaggle_dataset_name = "tmdb/tmdb-movie-metadata" +gold_answer = "12.92" +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 = "tmdb__tmdb-movie-metadata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "12.92" +QUESTION = "What is the median popularity score across all movies 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/0085_952_85952796_qa_1/instruction.md b/tasks/0085_952_85952796_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e1ae5a87bd5ba9adb08106b680fa7c9d34f1a3fb --- /dev/null +++ b/tasks/0085_952_85952796_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): +- Video_Games_Sales_as_at_22_Dec_2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean absolute deviation of User_Score from its mean value 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/0085_952_85952796_qa_1/task.toml b/tasks/0085_952_85952796_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..810a8f5c225f8505af371c105398743f0ea656e4 --- /dev/null +++ b/tasks/0085_952_85952796_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0085_952_85952796_qa_1" +description = "What is the mean absolute deviation of User_Score from its mean value in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0085/952/85952796.ipynb_qa_1" +kaggle_dataset_name = "rush4ratio/video-game-sales-with-ratings" +gold_answer = "1.155" +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 = "rush4ratio__video-game-sales-with-ratings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rush4ratio/video-game-sales-with-ratings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.155" +QUESTION = "What is the mean absolute deviation of User_Score from its mean value 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/0086_531_86531254_qa_5/instruction.md b/tasks/0086_531_86531254_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..212497fb280a0f2f1b048636cbc97bcf2a25e3d7 --- /dev/null +++ b/tasks/0086_531_86531254_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: +Which video game genre represents the largest portion of sales in Japan (JP_Sales) based on the pie chart visualization? + +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/0086_531_86531254_qa_5/task.toml b/tasks/0086_531_86531254_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..63ec0c685458615792117e95cfe545d6c6eadce4 --- /dev/null +++ b/tasks/0086_531_86531254_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0086_531_86531254_qa_5" +description = "Which video game genre represents the largest portion of sales in Japan (JP_Sales) based on the pie chart visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0086/531/86531254.ipynb_qa_5" +kaggle_dataset_name = "kedokedokedo/vgsales" +gold_answer = "Role-Playing" +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 = "kedokedokedo__vgsales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kedokedokedo/vgsales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Role-Playing" +QUESTION = "Which video game genre represents the largest portion of sales in Japan (JP_Sales) based on the pie chart visualization?" +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/0087_024_87024626_qa_4/instruction.md b/tasks/0087_024_87024626_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..eb922b9226d27bdac4a615fb17c3c42df6579e9c --- /dev/null +++ b/tasks/0087_024_87024626_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): +- Autism_Data.arff + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the country of residence with the highest number of individuals represented in the dataset after grouping infrequent entries into "Others"? + +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/0087_024_87024626_qa_4/task.toml b/tasks/0087_024_87024626_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d3e57a59802934910228df5e1cb479cbf59c572f --- /dev/null +++ b/tasks/0087_024_87024626_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0087_024_87024626_qa_4" +description = "What is the country of residence with the highest number of individuals represented in the dataset after grouping infrequent entries into \"Others\"?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/024/87024626.ipynb_qa_4" +kaggle_dataset_name = "faizunnabi/autism-screening" +gold_answer = "United States" +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 = "faizunnabi__autism-screening" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "faizunnabi/autism-screening" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "United States" +QUESTION = "What is the country of residence with the highest number of individuals represented in the dataset after grouping infrequent entries into \"Others\"?" +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/0087_320_87320991_qa_1/instruction.md b/tasks/0087_320_87320991_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f50257bc8807bb9d1bb46f158b645c3b7b3af242 --- /dev/null +++ b/tasks/0087_320_87320991_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 variable for predicting mobile price ranges using the ExtraTreesClassifier feature importance 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/0087_320_87320991_qa_1/task.toml b/tasks/0087_320_87320991_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1b16269ffc9fa246d61f8e0011ad0a7e7268545b --- /dev/null +++ b/tasks/0087_320_87320991_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0087_320_87320991_qa_1" +description = "Which feature was identified as the most important variable for predicting mobile price ranges using the ExtraTreesClassifier feature importance analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/320/87320991.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "ram" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "ram" +QUESTION = "Which feature was identified as the most important variable for predicting mobile price ranges using the ExtraTreesClassifier feature importance analysis?" +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/0087_349_87349607_qa_1/instruction.md b/tasks/0087_349_87349607_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e5a2db0ccc4f90723ea4629ccec19421d12d0e01 --- /dev/null +++ b/tasks/0087_349_87349607_qa_1/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): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the distribution of the price_range in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as comma-separated : pairs. + +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/0087_349_87349607_qa_1/task.toml b/tasks/0087_349_87349607_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bc849a02ee3b99bc144ada018ad9086b74628215 --- /dev/null +++ b/tasks/0087_349_87349607_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0087_349_87349607_qa_1" +description = "What is the distribution of the price_range in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/349/87349607.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "0:500, 1:500, 2:500, 3:500" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0:500, 1:500, 2:500, 3:500" +QUESTION = "What is the distribution of the price_range in the dataset?" +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/0087_789_87789840_qa_1/instruction.md b/tasks/0087_789_87789840_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cbdd86d7e18f5cab92a05aae2c69153cd8d08778 --- /dev/null +++ b/tasks/0087_789_87789840_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): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the ratio of ham to spam messages in the SMS 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/0087_789_87789840_qa_1/task.toml b/tasks/0087_789_87789840_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..298a83120d4de365670044cd3799130e48aa257e --- /dev/null +++ b/tasks/0087_789_87789840_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0087_789_87789840_qa_1" +description = "What is the ratio of ham to spam messages in the SMS dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/789/87789840.ipynb_qa_1" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "6.5" +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__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 = "6.5" +QUESTION = "What is the ratio of ham to spam messages in the SMS 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/0087_867_87867765_qa_2/instruction.md b/tasks/0087_867_87867765_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ab10a4f2a27ff7134b8483d556dff3e200fcc53d --- /dev/null +++ b/tasks/0087_867_87867765_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: +What is the median living area (sqft_living) of the houses 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/0087_867_87867765_qa_2/task.toml b/tasks/0087_867_87867765_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fa79bfb5b1807519cc0a4a640f1ba3492d4933a2 --- /dev/null +++ b/tasks/0087_867_87867765_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0087_867_87867765_qa_2" +description = "What is the median living area (sqft_living) of the houses in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/867/87867765.ipynb_qa_2" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "1910" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1910" +QUESTION = "What is the median living area (sqft_living) of the houses 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/0087_867_87867765_qa_5/instruction.md b/tasks/0087_867_87867765_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a76e4ce51d70ea7970980bb6b4fb844248028317 --- /dev/null +++ b/tasks/0087_867_87867765_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): +- 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 range of the year the houses were built (from the oldest to the newest)? + +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/0087_867_87867765_qa_5/task.toml b/tasks/0087_867_87867765_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b8f5d5f2a956a0fe38a085c778e4464dcfa5c89a --- /dev/null +++ b/tasks/0087_867_87867765_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0087_867_87867765_qa_5" +description = "What is the range of the year the houses were built (from the oldest to the newest)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/867/87867765.ipynb_qa_5" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "115" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "115" +QUESTION = "What is the range of the year the houses were built (from the oldest to the newest)?" +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/0087_893_87893220_qa_2/instruction.md b/tasks/0087_893_87893220_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..75d1b1ba05dd1d6c98f27e42f3e96132bd021900 --- /dev/null +++ b/tasks/0087_893_87893220_qa_2/instruction.md @@ -0,0 +1,19 @@ +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): +- MedianHouseholdIncome2015.csv +- PercentagePeopleBelowPovertyLevel.csv +- PercentOver25CompletedHighSchool.csv +- ShareRaceByCity.csv +- PoliceKillingsUS.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the frequency of the most common name or surname among the victims listed in the police shooting 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/0087_893_87893220_qa_2/task.toml b/tasks/0087_893_87893220_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..afc0917ddf7c05793f762ef5f1965b0b75518df6 --- /dev/null +++ b/tasks/0087_893_87893220_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0087_893_87893220_qa_2" +description = "What is the frequency of the most common name or surname among the victims listed in the police shooting dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/893/87893220.ipynb_qa_2" +kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us" +gold_answer = "91" +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 = "kwullum__fatal-police-shootings-in-the-us" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "91" +QUESTION = "What is the frequency of the most common name or surname among the victims listed in the police shooting 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/0088_108_88108629_qa_1/instruction.md b/tasks/0088_108_88108629_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..efa201cd56ca03c055d9ead81de4219d005c00f2 --- /dev/null +++ b/tasks/0088_108_88108629_qa_1/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): +- mtcars.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average miles per gallon (mpg) for manual transmission cars compared to automatic transmission cars in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: : pairs, comma-separated, with the transmission type label first and the mpg value as a plain number with two decimals. + +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/0088_108_88108629_qa_1/task.toml b/tasks/0088_108_88108629_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..834e8672d9e134ec21c548492ff1a8f8934655f7 --- /dev/null +++ b/tasks/0088_108_88108629_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0088_108_88108629_qa_1" +description = "What is the average miles per gallon (mpg) for manual transmission cars compared to automatic transmission cars in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0088/108/88108629.ipynb_qa_1" +kaggle_dataset_name = "ruiromanini/mtcars" +gold_answer = "Manual: 24.39, Automatic: 17.15" +reward_mode_initial = "list" +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 = "ruiromanini__mtcars" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ruiromanini/mtcars" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Manual: 24.39, Automatic: 17.15" +QUESTION = "What is the average miles per gallon (mpg) for manual transmission cars compared to automatic transmission cars in the dataset?" +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/0088_214_88214420_qa_3/instruction.md b/tasks/0088_214_88214420_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b3f65ff5dc5d1d39081bc1a0afbcf76c9aeee207 --- /dev/null +++ b/tasks/0088_214_88214420_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): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which class (spam or ham) has a higher standard deviation in message lengths? + +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/0088_214_88214420_qa_3/task.toml b/tasks/0088_214_88214420_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bd4455007c2d1d296faacc8a67810daf55fc0861 --- /dev/null +++ b/tasks/0088_214_88214420_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0088_214_88214420_qa_3" +description = "Which class (spam or ham) has a higher standard deviation in message lengths?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0088/214/88214420.ipynb_qa_3" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "ham" +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__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 = "ham" +QUESTION = "Which class (spam or ham) has a higher standard deviation in message lengths?" +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/0088_550_88550730_qa_1/instruction.md b/tasks/0088_550_88550730_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a6df4bb1fc32f59d0fea7c0e9781f4e3cca68d7d --- /dev/null +++ b/tasks/0088_550_88550730_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: +Which feature in the Boston housing dataset shows the highest absolute correlation with the median home value (MEDV)? + +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/0088_550_88550730_qa_1/task.toml b/tasks/0088_550_88550730_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1727c40321049d668055f4a0543f5750e62e9447 --- /dev/null +++ b/tasks/0088_550_88550730_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0088_550_88550730_qa_1" +description = "Which feature in the Boston housing dataset shows the highest absolute correlation with the median home value (MEDV)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0088/550/88550730.ipynb_qa_1" +kaggle_dataset_name = "vikrishnan/boston-house-prices" +gold_answer = "LSTAT" +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 = "vikrishnan__boston-house-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vikrishnan/boston-house-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "LSTAT" +QUESTION = "Which feature in the Boston housing dataset shows the highest absolute correlation with the median home value (MEDV)?" +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/0088_720_88720224_qa_1/instruction.md b/tasks/0088_720_88720224_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6869a9e9cf2ec0afe34937790ab7ffc3df80857d --- /dev/null +++ b/tasks/0088_720_88720224_qa_1/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the original training data remained after dropping rows with missing values in Product_Category_2 and removing Product_Category_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/0088_720_88720224_qa_1/task.toml b/tasks/0088_720_88720224_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c577286bf3368221957e5abd56da7d1badb82445 --- /dev/null +++ b/tasks/0088_720_88720224_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0088_720_88720224_qa_1" +description = "What percentage of the original training data remained after dropping rows with missing values in Product_Category_2 and removing Product_Category_3?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0088/720/88720224.ipynb_qa_1" +kaggle_dataset_name = "sdolezel/black-friday" +gold_answer = "68.43" +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 = "sdolezel__black-friday" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sdolezel/black-friday" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "68.43" +QUESTION = "What percentage of the original training data remained after dropping rows with missing values in Product_Category_2 and removing Product_Category_3?" +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/0088_996_88996860_qa_1/instruction.md b/tasks/0088_996_88996860_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b23e5cdb2b051ff983c693cb31d638396ee665ab --- /dev/null +++ b/tasks/0088_996_88996860_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest positive correlation coefficient between any feature and the 'Outcome' variable after handling missing values and outliers? + +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/0088_996_88996860_qa_1/task.toml b/tasks/0088_996_88996860_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c5df9e931394c114bd92fb6652afd0995faa7fa4 --- /dev/null +++ b/tasks/0088_996_88996860_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0088_996_88996860_qa_1" +description = "What is the highest positive correlation coefficient between any feature and the 'Outcome' variable after handling missing values and outliers?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0088/996/88996860.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0.492928" +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__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.492928" +QUESTION = "What is the highest positive correlation coefficient between any feature and the 'Outcome' variable after handling missing values and outliers?" +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/0089_547_89547343_qa_2/instruction.md b/tasks/0089_547_89547343_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d13dbb53a2a83bac1784e2cfdaf848c80ebfa805 --- /dev/null +++ b/tasks/0089_547_89547343_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: +How many features are present in the dataset after removing the `veil-type` column? + +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/0089_547_89547343_qa_2/task.toml b/tasks/0089_547_89547343_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a537125989ce784655408b4badb4e26573513566 --- /dev/null +++ b/tasks/0089_547_89547343_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0089_547_89547343_qa_2" +description = "How many features are present in the dataset after removing the `veil-type` column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0089/547/89547343.ipynb_qa_2" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "22" +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 = "22" +QUESTION = "How many features are present in the dataset after removing the `veil-type` column?" +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/0090_524_90524053_qa_1/instruction.md b/tasks/0090_524_90524053_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d4b4668d3b673e67b6b9cf26cf8e38d0ba419d00 --- /dev/null +++ b/tasks/0090_524_90524053_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: +Which wine quality rating has the highest total sulfur dioxide levels? + +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/0090_524_90524053_qa_1/task.toml b/tasks/0090_524_90524053_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b0ff493c973fe57a0da7804d04f6d764c793e508 --- /dev/null +++ b/tasks/0090_524_90524053_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0090_524_90524053_qa_1" +description = "Which wine quality rating has the highest total sulfur dioxide levels?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0090/524/90524053.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "5" +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__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 = "5" +QUESTION = "Which wine quality rating has the highest total sulfur dioxide levels?" +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/0091_122_91122496_qa_5/instruction.md b/tasks/0091_122_91122496_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8305739dfca4cb59bac796998c996172f41d0af3 --- /dev/null +++ b/tasks/0091_122_91122496_qa_5/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): +- Features data set.csv +- sales data-set.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the direction of the relationship between CPI and Weekly_Sales based on the 95% confidence interval of its coefficient in the global 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/0091_122_91122496_qa_5/task.toml b/tasks/0091_122_91122496_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7a08c601c36576e1d56d10456f8d71bea9a771d0 --- /dev/null +++ b/tasks/0091_122_91122496_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0091_122_91122496_qa_5" +description = "What is the direction of the relationship between CPI and Weekly_Sales based on the 95% confidence interval of its coefficient in the global model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0091/122/91122496.ipynb_qa_5" +kaggle_dataset_name = "manjeetsingh/retaildataset" +gold_answer = "Negative" +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 = "manjeetsingh__retaildataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "manjeetsingh/retaildataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Negative" +QUESTION = "What is the direction of the relationship between CPI and Weekly_Sales based on the 95% confidence interval of its coefficient in the global model?" +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/0091_861_91861304_qa_1/instruction.md b/tasks/0091_861_91861304_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b1c903c7d45ce957e607c2134c4cec07d9f13780 --- /dev/null +++ b/tasks/0091_861_91861304_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of patients in the dataset diagnosed with diabetes (Outcome=1)? + +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/0091_861_91861304_qa_1/task.toml b/tasks/0091_861_91861304_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c8caed25ca04562399e1d914223583848d4762f3 --- /dev/null +++ b/tasks/0091_861_91861304_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0091_861_91861304_qa_1" +description = "What is the percentage of patients in the dataset diagnosed with diabetes (Outcome=1)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0091/861/91861304.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "34.9" +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__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 = "34.9" +QUESTION = "What is the percentage of patients in the dataset diagnosed with diabetes (Outcome=1)?" +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/0092_606_92606348_qa_3/instruction.md b/tasks/0092_606_92606348_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b2c7c9823e533f9210642039e9c0aee24c174659 --- /dev/null +++ b/tasks/0092_606_92606348_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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which model achieved the highest accuracy in predicting wine quality: Linear Regression, Decision Tree, or Random Forest? + +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_606_92606348_qa_3/task.toml b/tasks/0092_606_92606348_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fceacff17cc8c21bc2075d41570ad57cead54a63 --- /dev/null +++ b/tasks/0092_606_92606348_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0092_606_92606348_qa_3" +description = "Which model achieved the highest accuracy in predicting wine quality: Linear Regression, Decision Tree, or Random Forest?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0092/606/92606348.ipynb_qa_3" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "Random Forest" +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 = "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 = "Random Forest" +QUESTION = "Which model achieved the highest accuracy in predicting wine quality: Linear Regression, Decision Tree, or Random Forest?" +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/0092_606_92606348_qa_4/instruction.md b/tasks/0092_606_92606348_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..873848ca609a82bc57c7362f3b3f5f8b357a645d --- /dev/null +++ b/tasks/0092_606_92606348_qa_4/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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which wine quality rating has the highest maximum residual sugar, and what is that value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, rating first, keep decimals). + +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_606_92606348_qa_4/task.toml b/tasks/0092_606_92606348_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..015bf580fba8f6eb30bea5180c0ec5cca21a6be3 --- /dev/null +++ b/tasks/0092_606_92606348_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0092_606_92606348_qa_4" +description = "Which wine quality rating has the highest maximum residual sugar, and what is that value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0092/606/92606348.ipynb_qa_4" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "5, 15.5" +reward_mode_initial = "list" +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 = "5, 15.5" +QUESTION = "Which wine quality rating has the highest maximum residual sugar, and what is that value?" +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/0092_855_92855886_qa_1/instruction.md b/tasks/0092_855_92855886_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9f3981aa5476f2c0f0609c383bacd6afea37c9a7 --- /dev/null +++ b/tasks/0092_855_92855886_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): +- KAG_conversion_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which campaign has the highest Spent per 1000 Impressions (Spent/Imp(k)) based on the aggregated campaign metrics? + +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_855_92855886_qa_1/task.toml b/tasks/0092_855_92855886_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..556538f48f3983de0600200fe016b64684999b37 --- /dev/null +++ b/tasks/0092_855_92855886_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0092_855_92855886_qa_1" +description = "Which campaign has the highest Spent per 1000 Impressions (Spent/Imp(k)) based on the aggregated campaign metrics?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0092/855/92855886.ipynb_qa_1" +kaggle_dataset_name = "loveall/clicks-conversion-tracking" +gold_answer = "936" +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 = "loveall__clicks-conversion-tracking" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "loveall/clicks-conversion-tracking" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "936" +QUESTION = "Which campaign has the highest Spent per 1000 Impressions (Spent/Imp(k)) based on the aggregated campaign metrics?" +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/0094_116_94116653_qa_2/instruction.md b/tasks/0094_116_94116653_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d1d1eacd4322ef734adff4a6d7cd40aec28883ca --- /dev/null +++ b/tasks/0094_116_94116653_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: +Which feature shows the strongest positive correlation with the diabetes outcome in the correlation 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/0094_116_94116653_qa_2/task.toml b/tasks/0094_116_94116653_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..76ebfab802caa144dd8408daf0f5202f07f7d9c4 --- /dev/null +++ b/tasks/0094_116_94116653_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0094_116_94116653_qa_2" +description = "Which feature shows the strongest positive correlation with the diabetes outcome in the correlation analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0094/116/94116653.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +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__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 = "Which feature shows the strongest positive correlation with the diabetes outcome in the correlation analysis?" +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/0094_415_94415300_qa_4/instruction.md b/tasks/0094_415_94415300_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..958b2fd66ec51442401f967c90d104db42c81931 --- /dev/null +++ b/tasks/0094_415_94415300_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique education levels are present in the dataset after dropping the 'education' column and retaining 'education.num'? + +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/0094_415_94415300_qa_4/task.toml b/tasks/0094_415_94415300_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..794b74fb2f2568f0e3503d1b627ff581a7a6ca16 --- /dev/null +++ b/tasks/0094_415_94415300_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0094_415_94415300_qa_4" +description = "How many unique education levels are present in the dataset after dropping the 'education' column and retaining 'education.num'?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0094/415/94415300.ipynb_qa_4" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "16" +reward_mode_initial = "numeric" +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__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "16" +QUESTION = "How many unique education levels are present in the dataset after dropping the 'education' column and retaining 'education.num'?" +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/0094_540_94540451_qa_2/instruction.md b/tasks/0094_540_94540451_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..be48d65507c1ee2e049799d589d9ded1180a8715 --- /dev/null +++ b/tasks/0094_540_94540451_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: +Which video game genre had the highest market share in North America in 2008? + +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/0094_540_94540451_qa_2/task.toml b/tasks/0094_540_94540451_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6b547930a8c332e43fd59da3bab7e22923326472 --- /dev/null +++ b/tasks/0094_540_94540451_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0094_540_94540451_qa_2" +description = "Which video game genre had the highest market share in North America in 2008?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0094/540/94540451.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Action" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Action" +QUESTION = "Which video game genre had the highest market share in North America in 2008?" +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/0094_622_94622632_qa_2/instruction.md b/tasks/0094_622_94622632_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4ad848457d452323dccf73716bb941a1de1fa35a --- /dev/null +++ b/tasks/0094_622_94622632_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.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median age of passengers in the third class (Pclass=3) after imputing missing values using class-specific median imputation? + +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/0094_622_94622632_qa_2/task.toml b/tasks/0094_622_94622632_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f11dcc9453a228556ad6cb0716fef3a1d8e786c0 --- /dev/null +++ b/tasks/0094_622_94622632_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0094_622_94622632_qa_2" +description = "What is the median age of passengers in the third class (Pclass=3) after imputing missing values using class-specific median imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0094/622/94622632.ipynb_qa_2" +kaggle_dataset_name = "hesh97/titanicdataset-traincsv" +gold_answer = "24.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 = "hesh97__titanicdataset-traincsv" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hesh97/titanicdataset-traincsv" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "24.0" +QUESTION = "What is the median age of passengers in the third class (Pclass=3) after imputing missing values using class-specific median imputation?" +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_088_95088024_qa_1/instruction.md b/tasks/0095_088_95088024_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..455a10a899a8234dbd79916455f477efa5fa696c --- /dev/null +++ b/tasks/0095_088_95088024_qa_1/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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of variance in medical charges is explained by BMI for smokers compared to non-smokers in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list with each item in the form ": %", groups in the order , , and percentages as plain numbers (e.g., 65, 0.7). + +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_088_95088024_qa_1/task.toml b/tasks/0095_088_95088024_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6b9906bfd1d7048418c280ef6540aaf3c78b26ba --- /dev/null +++ b/tasks/0095_088_95088024_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0095_088_95088024_qa_1" +description = "What percentage of variance in medical charges is explained by BMI for smokers compared to non-smokers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/088/95088024.ipynb_qa_1" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "Smokers: 65%, Non-smokers: 0.7%" +reward_mode_initial = "list" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Smokers: 65%, Non-smokers: 0.7%" +QUESTION = "What percentage of variance in medical charges is explained by BMI for smokers compared to non-smokers in the dataset?" +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/0095_344_95344142_qa_3/instruction.md b/tasks/0095_344_95344142_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4d9a2a7f06064ecbe4216715b55afab8d7b99667 --- /dev/null +++ b/tasks/0095_344_95344142_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Does the dataset contain any missing or null values across all features? + +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_344_95344142_qa_3/task.toml b/tasks/0095_344_95344142_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b2ab1020c57bcec3a7d76a8b01d236a663b614aa --- /dev/null +++ b/tasks/0095_344_95344142_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0095_344_95344142_qa_3" +description = "Does the dataset contain any missing or null values across all features?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/344/95344142.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "no" +reward_mode_initial = "exact_bool" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "no" +QUESTION = "Does the dataset contain any missing or null values across all features?" +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/0095_344_95344142_qa_4/instruction.md b/tasks/0095_344_95344142_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cc78c78149ebc3f28683783dd540be29f92b07d8 --- /dev/null +++ b/tasks/0095_344_95344142_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum recorded petal width 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/0095_344_95344142_qa_4/task.toml b/tasks/0095_344_95344142_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5d35a8b1c6474a01cea2cb8eaf1c69347e67b4e3 --- /dev/null +++ b/tasks/0095_344_95344142_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0095_344_95344142_qa_4" +description = "What is the maximum recorded petal width in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/344/95344142.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "2.5" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2.5" +QUESTION = "What is the maximum recorded petal width 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/0095_624_95624401_qa_2/instruction.md b/tasks/0095_624_95624401_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..209ecbd14e845dbf65ab3854de6f16b5f6823b97 --- /dev/null +++ b/tasks/0095_624_95624401_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): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the distribution count of wine quality levels categorized as 'low', 'medium', and 'high' in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as comma-separated : pairs in the 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/0095_624_95624401_qa_2/task.toml b/tasks/0095_624_95624401_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4f3f78aed93c89a24fe276481ff4df30054ed5a2 --- /dev/null +++ b/tasks/0095_624_95624401_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0095_624_95624401_qa_2" +description = "What is the distribution count of wine quality levels categorized as 'low', 'medium', and 'high' in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/624/95624401.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "low: 744, medium: 638, high: 217" +reward_mode_initial = "list" +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__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 = "low: 744, medium: 638, high: 217" +QUESTION = "What is the distribution count of wine quality levels categorized as 'low', 'medium', and 'high' in the dataset?" +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/0095_843_95843375_qa_3/instruction.md b/tasks/0095_843_95843375_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5526d6f4c541b1b795159c0abf060b4552705162 --- /dev/null +++ b/tasks/0095_843_95843375_qa_3/instruction.md @@ -0,0 +1,20 @@ +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): +- Ball_by_Ball.csv +- Match.csv +- Player.csv +- Player_Match.csv +- Season.csv +- Team.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common type of dismissal 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/0095_843_95843375_qa_3/task.toml b/tasks/0095_843_95843375_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5988511dff61b0661c034bf6b72b490ae17f769a --- /dev/null +++ b/tasks/0095_843_95843375_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0095_843_95843375_qa_3" +description = "What is the most common type of dismissal in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/843/95843375.ipynb_qa_3" +kaggle_dataset_name = "harsha547/indian-premier-league-csv-dataset" +gold_answer = "caught" +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 = "harsha547__indian-premier-league-csv-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harsha547/indian-premier-league-csv-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "caught" +QUESTION = "What is the most common type of dismissal 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/0095_843_95843375_qa_4/instruction.md b/tasks/0095_843_95843375_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0b356f4eea9213ebb755340d5f7f3448036b09ab --- /dev/null +++ b/tasks/0095_843_95843375_qa_4/instruction.md @@ -0,0 +1,20 @@ +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): +- Ball_by_Ball.csv +- Match.csv +- Player.csv +- Player_Match.csv +- Season.csv +- Team.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Who is the highest run-scorer in the dataset based on total runs scored? + +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_843_95843375_qa_4/task.toml b/tasks/0095_843_95843375_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..408cd3559dc851c9fb7d33ea056741d293657ae7 --- /dev/null +++ b/tasks/0095_843_95843375_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0095_843_95843375_qa_4" +description = "Who is the highest run-scorer in the dataset based on total runs scored?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/843/95843375.ipynb_qa_4" +kaggle_dataset_name = "harsha547/indian-premier-league-csv-dataset" +gold_answer = "SK Raina" +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 = "harsha547__indian-premier-league-csv-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harsha547/indian-premier-league-csv-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "SK Raina" +QUESTION = "Who is the highest run-scorer in the dataset based on total runs scored?" +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/0096_064_96064872_qa_1/instruction.md b/tasks/0096_064_96064872_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6aab06c9c36a21c99043d9acd31a701d02a6e87c --- /dev/null +++ b/tasks/0096_064_96064872_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which regression model achieved the lowest RMSE in predicting TotalCharges? + +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/0096_064_96064872_qa_1/task.toml b/tasks/0096_064_96064872_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bf21ed14e4e190f53c259199e49457f0627c62a2 --- /dev/null +++ b/tasks/0096_064_96064872_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0096_064_96064872_qa_1" +description = "Which regression model achieved the lowest RMSE in predicting TotalCharges?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0096/064/96064872.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Random Forest" +reward_mode_initial = "exact_short" +package_tier = 2 +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Random Forest" +QUESTION = "Which regression model achieved the lowest RMSE in predicting TotalCharges?" +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/0096_765_96765273_qa_4/instruction.md b/tasks/0096_765_96765273_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..078412e458d9443951678cddc35059e69450d070 --- /dev/null +++ b/tasks/0096_765_96765273_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference in total global sales between the year with the highest sales (2008) and the year with the lowest sales (2017)? + +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/0096_765_96765273_qa_4/task.toml b/tasks/0096_765_96765273_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0a3b1bfd476995b6ebb4a6d81b50fbcd92e9423c --- /dev/null +++ b/tasks/0096_765_96765273_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0096_765_96765273_qa_4" +description = "What is the difference in total global sales between the year with the highest sales (2008) and the year with the lowest sales (2017)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0096/765/96765273.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "678.85" +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 = "678.85" +QUESTION = "What is the difference in total global sales between the year with the highest sales (2008) and the year with the lowest sales (2017)?" +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/0096_778_96778684_qa_2/instruction.md b/tasks/0096_778_96778684_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7c81e741320d1d86298f189718613b29d703c71f --- /dev/null +++ b/tasks/0096_778_96778684_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After applying the Box-Cox transformation, what is the p-value from the normality test on the target variable (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/0096_778_96778684_qa_2/task.toml b/tasks/0096_778_96778684_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e33580abd532903eed704c5274ac0da9770870d2 --- /dev/null +++ b/tasks/0096_778_96778684_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0096_778_96778684_qa_2" +description = "After applying the Box-Cox transformation, what is the p-value from the normality test on the target variable (charges)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0096/778/96778684.ipynb_qa_2" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "1.5249631686757666e-12" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.5249631686757666e-12" +QUESTION = "After applying the Box-Cox transformation, what is the p-value from the normality test on the target variable (charges)?" +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/0096_889_96889516_qa_5/instruction.md b/tasks/0096_889_96889516_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..39e4faf48d8207a13627e04edebbd22e71d8f2c1 --- /dev/null +++ b/tasks/0096_889_96889516_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 standard deviation of the Age feature in the original 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/0096_889_96889516_qa_5/task.toml b/tasks/0096_889_96889516_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..274260fec5f53fa54d1c3ec92fb4f9b33fb1f76a --- /dev/null +++ b/tasks/0096_889_96889516_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0096_889_96889516_qa_5" +description = "What is the standard deviation of the Age feature in the original dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0096/889/96889516.ipynb_qa_5" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "11.76" +reward_mode_initial = "numeric" +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__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 = "11.76" +QUESTION = "What is the standard deviation of the Age feature in the original 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/0097_698_97698987_qa_4/instruction.md b/tasks/0097_698_97698987_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..23a542ae08866a62ded6066af71a8ca88387da22 --- /dev/null +++ b/tasks/0097_698_97698987_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature exhibits the highest standard deviation, indicating the greatest variability in measurements across 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/0097_698_97698987_qa_4/task.toml b/tasks/0097_698_97698987_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7c310c25ceebd0528c35fa010b21183e763e4dd2 --- /dev/null +++ b/tasks/0097_698_97698987_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0097_698_97698987_qa_4" +description = "Which feature exhibits the highest standard deviation, indicating the greatest variability in measurements across the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0097/698/97698987.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalLengthCm" +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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PetalLengthCm" +QUESTION = "Which feature exhibits the highest standard deviation, indicating the greatest variability in measurements across 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/0097_708_97708214_qa_2/instruction.md b/tasks/0097_708_97708214_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..49be53191c90ea0263c6920f7bc8a73ee6436e9b --- /dev/null +++ b/tasks/0097_708_97708214_qa_2/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many numerical features are present in the test 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/0097_708_97708214_qa_2/task.toml b/tasks/0097_708_97708214_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..33a58c917c77569e2ccfbabcae95e5dc5dab0e48 --- /dev/null +++ b/tasks/0097_708_97708214_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0097_708_97708214_qa_2" +description = "How many numerical features are present in the test dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0097/708/97708214.ipynb_qa_2" +kaggle_dataset_name = "rashigoel/titanic-machine-learning-from-disaster" +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 = "rashigoel__titanic-machine-learning-from-disaster" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rashigoel/titanic-machine-learning-from-disaster" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many numerical features are present in the test 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/0097_809_97809761_qa_2/instruction.md b/tasks/0097_809_97809761_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..772bde908a77077674d782e13624e75b5969e3a8 --- /dev/null +++ b/tasks/0097_809_97809761_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): +- Life Expectancy Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which variable demonstrates the strongest negative correlation with life expectancy 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/0097_809_97809761_qa_2/task.toml b/tasks/0097_809_97809761_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ec7e5f5281ccefaf8b9b5438e9d352e895a38da9 --- /dev/null +++ b/tasks/0097_809_97809761_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0097_809_97809761_qa_2" +description = "Which variable demonstrates the strongest negative correlation with life expectancy in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0097/809/97809761.ipynb_qa_2" +kaggle_dataset_name = "kumarajarshi/life-expectancy-who" +gold_answer = "Adult Mortality" +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 = "kumarajarshi__life-expectancy-who" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Adult Mortality" +QUESTION = "Which variable demonstrates the strongest negative correlation with life expectancy 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/0098_910_98910010_qa_4/instruction.md b/tasks/0098_910_98910010_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5d8c379e68338ec882195cebfd274b37b69d5801 --- /dev/null +++ b/tasks/0098_910_98910010_qa_4/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean value of the feature with the highest negative correlation to price_range 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/0098_910_98910010_qa_4/task.toml b/tasks/0098_910_98910010_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ac9562125ca55d8c91c9ce0a622e44bf04ac162d --- /dev/null +++ b/tasks/0098_910_98910010_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0098_910_98910010_qa_4" +description = "What is the mean value of the feature with the highest negative correlation to price_range in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0098/910/98910010.ipynb_qa_4" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "0.503" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.503" +QUESTION = "What is the mean value of the feature with the highest negative correlation to price_range 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/0099_607_99607727_qa_4/instruction.md b/tasks/0099_607_99607727_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e50167780cf0a9b9d8d05df5eab29d9cb1eb06fd --- /dev/null +++ b/tasks/0099_607_99607727_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many standard deviations above the mean are the North American sales of the top-selling game compared to all games? + +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/0099_607_99607727_qa_4/task.toml b/tasks/0099_607_99607727_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..46c95519769c9d2e6714a914d1933c68c22b42a3 --- /dev/null +++ b/tasks/0099_607_99607727_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0099_607_99607727_qa_4" +description = "How many standard deviations above the mean are the North American sales of the top-selling game compared to all games?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0099/607/99607727.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "50.48" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "50.48" +QUESTION = "How many standard deviations above the mean are the North American sales of the top-selling game compared to all games?" +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/0099_630_99630146_qa_5/instruction.md b/tasks/0099_630_99630146_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a547ae9d644382ea73997e24909e279d3f100133 --- /dev/null +++ b/tasks/0099_630_99630146_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): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the size of the test dataset used for model evaluation in this 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/0099_630_99630146_qa_5/task.toml b/tasks/0099_630_99630146_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..846c6aec67526aa89801a34069b268d0812ee903 --- /dev/null +++ b/tasks/0099_630_99630146_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0099_630_99630146_qa_5" +description = "What is the size of the test dataset used for model evaluation in this analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0099/630/99630146.ipynb_qa_5" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "500" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "500" +QUESTION = "What is the size of the test dataset used for model evaluation in this analysis?" +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/0099_701_99701449_qa_3/instruction.md b/tasks/0099_701_99701449_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e962aa4c8a2348eca662f5376d42dd363b12882b --- /dev/null +++ b/tasks/0099_701_99701449_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): +- database.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the third most populous continent in terms of notable figures 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/0099_701_99701449_qa_3/task.toml b/tasks/0099_701_99701449_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..954b08ed371f45beb130ad846d520707a0538d19 --- /dev/null +++ b/tasks/0099_701_99701449_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0099_701_99701449_qa_3" +description = "What is the third most populous continent in terms of notable figures in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0099/701/99701449.ipynb_qa_3" +kaggle_dataset_name = "mit/pantheon-project" +gold_answer = "Asia" +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 = "mit__pantheon-project" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mit/pantheon-project" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Asia" +QUESTION = "What is the third most populous continent in terms of notable figures 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/0099_705_99705765_qa_5/instruction.md b/tasks/0099_705_99705765_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c28b4fd6d4555dc67158f86f540f8df7249a4b96 --- /dev/null +++ b/tasks/0099_705_99705765_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): +- housing.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 total_bedrooms column before imputation? + +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/0099_705_99705765_qa_5/task.toml b/tasks/0099_705_99705765_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1c16f4c46ba20e9268f0c64f0876bb7f7e0c5343 --- /dev/null +++ b/tasks/0099_705_99705765_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0099_705_99705765_qa_5" +description = "How many missing values were present in the total_bedrooms column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0099/705/99705765.ipynb_qa_5" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "207" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "207" +QUESTION = "How many missing values were present in the total_bedrooms column before imputation?" +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/0099_730_99730639_qa_2/instruction.md b/tasks/0099_730_99730639_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ef7158e098750cf5c9eebe5e2ba49537aaed9dca --- /dev/null +++ b/tasks/0099_730_99730639_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.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the sum of the values in the 'Sex' column after applying label encoding (where male=1 and female=0)? + +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/0099_730_99730639_qa_2/task.toml b/tasks/0099_730_99730639_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3da35f01b0911e9529a89d5d2ee9a5a424c7ea63 --- /dev/null +++ b/tasks/0099_730_99730639_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0099_730_99730639_qa_2" +description = "What is the sum of the values in the 'Sex' column after applying label encoding (where male=1 and female=0)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0099/730/99730639.ipynb_qa_2" +kaggle_dataset_name = "hesh97/titanicdataset-traincsv" +gold_answer = "577" +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 = "hesh97__titanicdataset-traincsv" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hesh97/titanicdataset-traincsv" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "577" +QUESTION = "What is the sum of the values in the 'Sex' column after applying label encoding (where male=1 and female=0)?" +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/0100_668_100668614_qa_1/instruction.md b/tasks/0100_668_100668614_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3b87e45014df71055d2093b06de8e0ed6e5a86b2 --- /dev/null +++ b/tasks/0100_668_100668614_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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which job role had the highest frequency among employees who left the company? + +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_668_100668614_qa_1/task.toml b/tasks/0100_668_100668614_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..09978cafc6c8ea8b3e97e876b05b92adb74a8b27 --- /dev/null +++ b/tasks/0100_668_100668614_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0100_668_100668614_qa_1" +description = "Which job role had the highest frequency among employees who left the company?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0100/668/100668614.ipynb_qa_1" +kaggle_dataset_name = "patelprashant/employee-attrition" +gold_answer = "Laboratory Technician" +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 = "patelprashant__employee-attrition" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "patelprashant/employee-attrition" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Laboratory Technician" +QUESTION = "Which job role had the highest frequency among employees who left the company?" +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_729_100729925_qa_4/instruction.md b/tasks/0100_729_100729925_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1b801df577d89727a97bb18c0331c60c1d89d885 --- /dev/null +++ b/tasks/0100_729_100729925_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the AUC score of the Logistic Regression model on the test set after data cleaning and feature selection? + +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_729_100729925_qa_4/task.toml b/tasks/0100_729_100729925_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d4f0d74fc772bc84cb967a4ec11e811b1483baf3 --- /dev/null +++ b/tasks/0100_729_100729925_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0100_729_100729925_qa_4" +description = "What was the AUC score of the Logistic Regression model on the test set after data cleaning and feature selection?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0100/729/100729925.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0.82" +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__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.82" +QUESTION = "What was the AUC score of the Logistic Regression model on the test set after data cleaning and feature selection?" +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/0101_232_101232922_qa_1/instruction.md b/tasks/0101_232_101232922_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2bb2a782cc28ada228d1b0972eb9ee9d9349dbdd --- /dev/null +++ b/tasks/0101_232_101232922_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): +- concrete_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which material component shows the strongest positive correlation with concrete compressive strength according to the heatmap 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/0101_232_101232922_qa_1/task.toml b/tasks/0101_232_101232922_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4949864d400f317a51a811db8e78b84721006ce8 --- /dev/null +++ b/tasks/0101_232_101232922_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0101_232_101232922_qa_1" +description = "Which material component shows the strongest positive correlation with concrete compressive strength according to the heatmap analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/232/101232922.ipynb_qa_1" +kaggle_dataset_name = "elikplim/concrete-compressive-strength-data-set" +gold_answer = "Cement" +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 = "elikplim__concrete-compressive-strength-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "elikplim/concrete-compressive-strength-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Cement" +QUESTION = "Which material component shows the strongest positive correlation with concrete compressive strength according to the heatmap analysis?" +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/0101_296_101296258_qa_3/instruction.md b/tasks/0101_296_101296258_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6649ca1db827d7a10157674c33738f5aef41fa93 --- /dev/null +++ b/tasks/0101_296_101296258_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: +What is the inertia value achieved by the KMeans clustering model with 5 clusters on the scaled 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/0101_296_101296258_qa_3/task.toml b/tasks/0101_296_101296258_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4fcbc49151e399595a8fbe4819b8a777de8de30b --- /dev/null +++ b/tasks/0101_296_101296258_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0101_296_101296258_qa_3" +description = "What is the inertia value achieved by the KMeans clustering model with 5 clusters on the scaled dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/296/101296258.ipynb_qa_3" +kaggle_dataset_name = "arjunbhasin2013/ccdata" +gold_answer = "91484.92413050328" +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 = "arjunbhasin2013__ccdata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arjunbhasin2013/ccdata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "91484.92413050328" +QUESTION = "What is the inertia value achieved by the KMeans clustering model with 5 clusters on the scaled 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/0101_507_101507712_qa_1/instruction.md b/tasks/0101_507_101507712_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6105152548ea70ac343b1c11fd21b175e4845a39 --- /dev/null +++ b/tasks/0101_507_101507712_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): +- household_power_consumption.txt + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which year between 2006-2010 had the highest total power consumption measured in watt-hour according to the yearly aggregation 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/0101_507_101507712_qa_1/task.toml b/tasks/0101_507_101507712_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d82bf24612a5477285e12fa9b0661f28bf09a761 --- /dev/null +++ b/tasks/0101_507_101507712_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0101_507_101507712_qa_1" +description = "Which year between 2006-2010 had the highest total power consumption measured in watt-hour according to the yearly aggregation analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/507/101507712.ipynb_qa_1" +kaggle_dataset_name = "uciml/electric-power-consumption-data-set" +gold_answer = "2007" +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__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 = "2007" +QUESTION = "Which year between 2006-2010 had the highest total power consumption measured in watt-hour according to the yearly aggregation analysis?" +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/0101_773_101773827_qa_4/instruction.md b/tasks/0101_773_101773827_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..20af6d4962ba5fe5a17c258bbbead78c91148865 --- /dev/null +++ b/tasks/0101_773_101773827_qa_4/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many features were selected for the final Decision Tree model used in prediction? + +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/0101_773_101773827_qa_4/task.toml b/tasks/0101_773_101773827_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7cf0115ef5a44d3555c5f3449570c6b94d2cd5d8 --- /dev/null +++ b/tasks/0101_773_101773827_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0101_773_101773827_qa_4" +description = "How many features were selected for the final Decision Tree model used in prediction?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/773/101773827.ipynb_qa_4" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "4" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "How many features were selected for the final Decision Tree model used in prediction?" +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/0101_866_101866934_qa_4/instruction.md b/tasks/0101_866_101866934_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5a7a02f53bae39f075082216f88c433f8d26f8c3 --- /dev/null +++ b/tasks/0101_866_101866934_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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common age among employees 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/0101_866_101866934_qa_4/task.toml b/tasks/0101_866_101866934_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4e52e8ee1d9c82c1fb4a68a30a18a2c75d2de904 --- /dev/null +++ b/tasks/0101_866_101866934_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0101_866_101866934_qa_4" +description = "What is the most common age among employees in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/866/101866934.ipynb_qa_4" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "35" +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 = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "35" +QUESTION = "What is the most common age among employees 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/0101_994_101994234_qa_4/instruction.md b/tasks/0101_994_101994234_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..41c3699c95f39b6dfbdae89d6482bdd52c20c806 --- /dev/null +++ b/tasks/0101_994_101994234_qa_4/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the 75th percentile value of the 'x' variable in the test 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/0101_994_101994234_qa_4/task.toml b/tasks/0101_994_101994234_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4ad65ff5213075d60ab141150133702db5616458 --- /dev/null +++ b/tasks/0101_994_101994234_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0101_994_101994234_qa_4" +description = "What is the 75th percentile value of the 'x' variable in the test dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/994/101994234.ipynb_qa_4" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "73.0" +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 = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "73.0" +QUESTION = "What is the 75th percentile value of the 'x' variable in the test 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/0102_198_102198537_qa_5/instruction.md b/tasks/0102_198_102198537_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2e524a98b815597c9d8c47d324dca92f4abfbba4 --- /dev/null +++ b/tasks/0102_198_102198537_qa_5/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): +- stores data-set.csv +- Features data set.csv +- sales data-set.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average weekly sales value across all records in the sales 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/0102_198_102198537_qa_5/task.toml b/tasks/0102_198_102198537_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..779136e9f534e6711479c86bae9e224a045a9949 --- /dev/null +++ b/tasks/0102_198_102198537_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0102_198_102198537_qa_5" +description = "What is the average weekly sales value across all records in the sales dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0102/198/102198537.ipynb_qa_5" +kaggle_dataset_name = "manjeetsingh/retaildataset" +gold_answer = "15981.26" +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 = "manjeetsingh__retaildataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "manjeetsingh/retaildataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "15981.26" +QUESTION = "What is the average weekly sales value across all records in the sales 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/0102_369_102369672_qa_1/instruction.md b/tasks/0102_369_102369672_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c7e4f553140150d55f00cd2bd766c5a4c3b3791f --- /dev/null +++ b/tasks/0102_369_102369672_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): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the 35th percentile value for the calories column 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/0102_369_102369672_qa_1/task.toml b/tasks/0102_369_102369672_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..83b124cc1ed61eae1d6ea75698837ec88f411a40 --- /dev/null +++ b/tasks/0102_369_102369672_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0102_369_102369672_qa_1" +description = "What is the 35th percentile value for the calories column in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0102/369/102369672.ipynb_qa_1" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "100.0" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "100.0" +QUESTION = "What is the 35th percentile value for the calories column 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/0102_377_102377716_qa_4/instruction.md b/tasks/0102_377_102377716_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..af4325eac4ebd1ca9c881919d51f76e1feb8288e --- /dev/null +++ b/tasks/0102_377_102377716_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference between the highest and lowest global sales in the top 20 games? + +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/0102_377_102377716_qa_4/task.toml b/tasks/0102_377_102377716_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..918bb5b61491410d4f1ea99d0c50b802c623216b --- /dev/null +++ b/tasks/0102_377_102377716_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0102_377_102377716_qa_4" +description = "What is the difference between the highest and lowest global sales in the top 20 games?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0102/377/102377716.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "62.52" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "62.52" +QUESTION = "What is the difference between the highest and lowest global sales in the top 20 games?" +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/0102_378_102378485_qa_2/instruction.md b/tasks/0102_378_102378485_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..73a385dada0958366e6c82cc0dc78533f7af41cf --- /dev/null +++ b/tasks/0102_378_102378485_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): +- IMDB Horror movies.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the movies in the dataset are produced in English language (considering only languages with ≥20 movies)? + +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/0102_378_102378485_qa_2/task.toml b/tasks/0102_378_102378485_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1ebe933804153f2e6c43176358769b427a352ac4 --- /dev/null +++ b/tasks/0102_378_102378485_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0102_378_102378485_qa_2" +description = "What percentage of the movies in the dataset are produced in English language (considering only languages with ≥20 movies)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0102/378/102378485.ipynb_qa_2" +kaggle_dataset_name = "PromptCloudHQ/imdb-horror-movie-dataset" +gold_answer = "82" +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 = "PromptCloudHQ__imdb-horror-movie-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "PromptCloudHQ/imdb-horror-movie-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82" +QUESTION = "What percentage of the movies in the dataset are produced in English language (considering only languages with ≥20 movies)?" +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/0102_982_102982156_qa_3/instruction.md b/tasks/0102_982_102982156_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6c247be9722ee7895fb94fb1aebeec7b09afe319 --- /dev/null +++ b/tasks/0102_982_102982156_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: +What is the area under the ROC curve (AUC) achieved by the XGBoost model on the test 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/0102_982_102982156_qa_3/task.toml b/tasks/0102_982_102982156_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..74262f070c7cf8e845daa666eea957041cf18b3b --- /dev/null +++ b/tasks/0102_982_102982156_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0102_982_102982156_qa_3" +description = "What is the area under the ROC curve (AUC) achieved by the XGBoost model on the test dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0102/982/102982156.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.9844" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "0.9844" +QUESTION = "What is the area under the ROC curve (AUC) achieved by the XGBoost model on the test 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/0102_982_102982156_qa_4/instruction.md b/tasks/0102_982_102982156_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5677066f41da6e547e5094d61abf8a0b2983e772 --- /dev/null +++ b/tasks/0102_982_102982156_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: +How many instances were misclassified by the XGBoost model in the validation dataset based on the confusion matrix at the maximum F1 score threshold? + +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/0102_982_102982156_qa_4/task.toml b/tasks/0102_982_102982156_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c8e31b69700c640d078600fab459381e77a1827f --- /dev/null +++ b/tasks/0102_982_102982156_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0102_982_102982156_qa_4" +description = "How many instances were misclassified by the XGBoost model in the validation dataset based on the confusion matrix at the maximum F1 score threshold?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0102/982/102982156.ipynb_qa_4" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "2" +reward_mode_initial = "numeric" +package_tier = 3 +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 instances were misclassified by the XGBoost model in the validation dataset based on the confusion matrix at the maximum F1 score threshold?" +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/0103_290_103290674_qa_3/instruction.md b/tasks/0103_290_103290674_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8bf39409c2ee856476fd0740e3a0ea082139d677 --- /dev/null +++ b/tasks/0103_290_103290674_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: +Which feature in the original dataset has only one unique value? + +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/0103_290_103290674_qa_3/task.toml b/tasks/0103_290_103290674_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b8b4f9fc291e9d0ebe8223f95948113973501215 --- /dev/null +++ b/tasks/0103_290_103290674_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0103_290_103290674_qa_3" +description = "Which feature in the original dataset has only one unique value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0103/290/103290674.ipynb_qa_3" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "veil-type" +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 = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "veil-type" +QUESTION = "Which feature in the original dataset has only one unique value?" +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/0103_290_103290674_qa_4/instruction.md b/tasks/0103_290_103290674_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..704371d90bd762a05827e3715b0e37c6790827c9 --- /dev/null +++ b/tasks/0103_290_103290674_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: +What is the most common value in the 'cap-shape' feature? + +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/0103_290_103290674_qa_4/task.toml b/tasks/0103_290_103290674_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dfa6e2041aa68a8736f197cae4d374f262c9e671 --- /dev/null +++ b/tasks/0103_290_103290674_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0103_290_103290674_qa_4" +description = "What is the most common value in the 'cap-shape' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0103/290/103290674.ipynb_qa_4" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "x" +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 = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "x" +QUESTION = "What is the most common value in the 'cap-shape' feature?" +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/0103_514_103514732_qa_5/instruction.md b/tasks/0103_514_103514732_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c93baef0fd3217e0b21a89053f53f5b44a3eaea3 --- /dev/null +++ b/tasks/0103_514_103514732_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the original dataset was used for training based on the train-test split? + +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/0103_514_103514732_qa_5/task.toml b/tasks/0103_514_103514732_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..20b82f7061aa7e4272fc9bb752df5b5ad3f5088e --- /dev/null +++ b/tasks/0103_514_103514732_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0103_514_103514732_qa_5" +description = "What percentage of the original dataset was used for training based on the train-test split?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0103/514/103514732.ipynb_qa_5" +kaggle_dataset_name = "limkongkong/airpassengers" +gold_answer = "80" +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 = "limkongkong__airpassengers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "limkongkong/airpassengers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "80" +QUESTION = "What percentage of the original dataset was used for training based on the train-test split?" +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/0103_884_103884351_qa_1/instruction.md b/tasks/0103_884_103884351_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c1fb9b0bf71d64b9f5a40b3497d8c9705708c6e6 --- /dev/null +++ b/tasks/0103_884_103884351_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of individuals in the dataset have an income greater than $50K? + +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/0103_884_103884351_qa_1/task.toml b/tasks/0103_884_103884351_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d497950a8bbf54c044008402265b4d9b2ddb79e4 --- /dev/null +++ b/tasks/0103_884_103884351_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0103_884_103884351_qa_1" +description = "What percentage of individuals in the dataset have an income greater than $50K?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0103/884/103884351.ipynb_qa_1" +kaggle_dataset_name = "wenruliu/adult-income-dataset" +gold_answer = "23.9" +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 = "wenruliu__adult-income-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wenruliu/adult-income-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "23.9" +QUESTION = "What percentage of individuals in the dataset have an income greater than $50K?" +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/0104_138_104138961_qa_3/instruction.md b/tasks/0104_138_104138961_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2aa6ef3da91010e3d168e06166f289580b7ae250 --- /dev/null +++ b/tasks/0104_138_104138961_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: +What is the baseline accuracy achieved by predicting the majority class in the diagnosis column of 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/0104_138_104138961_qa_3/task.toml b/tasks/0104_138_104138961_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..98ac1a108c8573e96b92ab209e48cafaf5e810b4 --- /dev/null +++ b/tasks/0104_138_104138961_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0104_138_104138961_qa_3" +description = "What is the baseline accuracy achieved by predicting the majority class in the diagnosis column of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/138/104138961.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "62.74" +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__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 = "62.74" +QUESTION = "What is the baseline accuracy achieved by predicting the majority class in the diagnosis column of 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/0104_172_104172936_qa_3/instruction.md b/tasks/0104_172_104172936_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..274f49cf0d02872c5737fab8d1808124d46d3e79 --- /dev/null +++ b/tasks/0104_172_104172936_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): +- Transformed Data Set - Sheet1.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which "Favorite Soft Drink" category has the highest average male proportion based on the gender mapping (0=F, 1=M)? + +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/0104_172_104172936_qa_3/task.toml b/tasks/0104_172_104172936_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..60ea19227fcd16b311d4bc0441eec6b30adada35 --- /dev/null +++ b/tasks/0104_172_104172936_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0104_172_104172936_qa_3" +description = "Which \"Favorite Soft Drink\" category has the highest average male proportion based on the gender mapping (0=F, 1=M)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/172/104172936.ipynb_qa_3" +kaggle_dataset_name = "hb20007/gender-classification" +gold_answer = "Other" +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 = "hb20007__gender-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hb20007/gender-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Other" +QUESTION = "Which \"Favorite Soft Drink\" category has the highest average male proportion based on the gender mapping (0=F, 1=M)?" +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/0104_194_104194599_qa_4/instruction.md b/tasks/0104_194_104194599_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c15068e381c6713114cade6426d8128999cb7e64 --- /dev/null +++ b/tasks/0104_194_104194599_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average BMI for individuals with exactly 3 children 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/0104_194_104194599_qa_4/task.toml b/tasks/0104_194_104194599_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9f351659f1b90cbe75fdcfac29bc99b65e105285 --- /dev/null +++ b/tasks/0104_194_104194599_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0104_194_104194599_qa_4" +description = "What is the average BMI for individuals with exactly 3 children in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/194/104194599.ipynb_qa_4" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "30.68" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "30.68" +QUESTION = "What is the average BMI for individuals with exactly 3 children 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/0104_261_104261356_qa_5/instruction.md b/tasks/0104_261_104261356_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f7f6b780a99e9b98ad8c8f5c913092f252474c01 --- /dev/null +++ b/tasks/0104_261_104261356_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median insurance charge across all individuals 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/0104_261_104261356_qa_5/task.toml b/tasks/0104_261_104261356_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..095e77d53646e8601db4efd447f23cc5437abc17 --- /dev/null +++ b/tasks/0104_261_104261356_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0104_261_104261356_qa_5" +description = "What is the median insurance charge across all individuals in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/261/104261356.ipynb_qa_5" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "9382.033" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "9382.033" +QUESTION = "What is the median insurance charge across all individuals 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/0104_567_104567275_qa_5/instruction.md b/tasks/0104_567_104567275_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a792ecdc8c9e1a6b2596a1b9fa028e06e9114693 --- /dev/null +++ b/tasks/0104_567_104567275_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many categorical variables were label encoded 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/0104_567_104567275_qa_5/task.toml b/tasks/0104_567_104567275_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..307612e188cfbaab54dac57dd01fc7e9ca571d85 --- /dev/null +++ b/tasks/0104_567_104567275_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0104_567_104567275_qa_5" +description = "How many categorical variables were label encoded in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/567/104567275.ipynb_qa_5" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "3" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many categorical variables were label encoded 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/0104_868_104868299_qa_1/instruction.md b/tasks/0104_868_104868299_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..115d3ce6f74b17b56bda3fcfab34a7595e038fd3 --- /dev/null +++ b/tasks/0104_868_104868299_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 percentage of patients survived more than 5 years after treatment 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/0104_868_104868299_qa_1/task.toml b/tasks/0104_868_104868299_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9988fcf6363aad8b0da512ec9d846b120095616f --- /dev/null +++ b/tasks/0104_868_104868299_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0104_868_104868299_qa_1" +description = "What percentage of patients survived more than 5 years after treatment according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/868/104868299.ipynb_qa_1" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "73.53" +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 = "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 = "73.53" +QUESTION = "What percentage of patients survived more than 5 years after treatment according to 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/0105_301_105301672_qa_2/instruction.md b/tasks/0105_301_105301672_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a60b4584227c478ebd9aabfc0ebe977f322d955f --- /dev/null +++ b/tasks/0105_301_105301672_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): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which numerical variable shows the strongest positive correlation with Attrition after categorical encoding? + +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/0105_301_105301672_qa_2/task.toml b/tasks/0105_301_105301672_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..733c2a82a02c8b78fcbd010a673db4617d82cc5f --- /dev/null +++ b/tasks/0105_301_105301672_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0105_301_105301672_qa_2" +description = "Which numerical variable shows the strongest positive correlation with Attrition after categorical encoding?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0105/301/105301672.ipynb_qa_2" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "OverTime" +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 = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "OverTime" +QUESTION = "Which numerical variable shows the strongest positive correlation with Attrition after categorical encoding?" +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/0106_208_106208028_qa_1/instruction.md b/tasks/0106_208_106208028_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1182d08ae058b4ae7c3e773eb67ddb5f7446c0e4 --- /dev/null +++ b/tasks/0106_208_106208028_qa_1/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which model achieved the highest average testing accuracy across all KFold cross-validation splits? + +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/0106_208_106208028_qa_1/task.toml b/tasks/0106_208_106208028_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..74676bf68f6446360ac095f70329dabbfd9d8f16 --- /dev/null +++ b/tasks/0106_208_106208028_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0106_208_106208028_qa_1" +description = "Which model achieved the highest average testing accuracy across all KFold cross-validation splits?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0106/208/106208028.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "Logistic Regression" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Logistic Regression" +QUESTION = "Which model achieved the highest average testing accuracy across all KFold cross-validation splits?" +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/0106_229_106229633_qa_1/instruction.md b/tasks/0106_229_106229633_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b4085e509e3066fe81c36b4f78e69b80ae509bf5 --- /dev/null +++ b/tasks/0106_229_106229633_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which payment method has the highest proportion of customers who churned 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/0106_229_106229633_qa_1/task.toml b/tasks/0106_229_106229633_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d66477c82a7fc55d0f47c78cd93eb15c866f2308 --- /dev/null +++ b/tasks/0106_229_106229633_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0106_229_106229633_qa_1" +description = "Which payment method has the highest proportion of customers who churned in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0106/229/106229633.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Electronic check" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Electronic check" +QUESTION = "Which payment method has the highest proportion of customers who churned 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/0106_416_106416910_qa_1/instruction.md b/tasks/0106_416_106416910_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..688a6ca16bcf407d16b9a9c7a120d2b49665e656 --- /dev/null +++ b/tasks/0106_416_106416910_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of customers who churned in the dataset after data cleaning? + +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/0106_416_106416910_qa_1/task.toml b/tasks/0106_416_106416910_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d13a5a75baec8e8e20ca7e62d81b8b5a68b88a68 --- /dev/null +++ b/tasks/0106_416_106416910_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0106_416_106416910_qa_1" +description = "What is the percentage of customers who churned in the dataset after data cleaning?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0106/416/106416910.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "26.54" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "26.54" +QUESTION = "What is the percentage of customers who churned in the dataset after data cleaning?" +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/0107_521_107521812_qa_2/instruction.md b/tasks/0107_521_107521812_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..76d06eb0df98958cc7d4e43be710ccba9cdd93e1 --- /dev/null +++ b/tasks/0107_521_107521812_qa_2/instruction.md @@ -0,0 +1,18 @@ +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 +- test.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 decision tree classifier on the test set after feature scaling and train-test split? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a percentage (e.g. 95.5), not a fraction. + +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_521_107521812_qa_2/task.toml b/tasks/0107_521_107521812_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c4c13ee5d25c80534957e51902df019361d8cb4d --- /dev/null +++ b/tasks/0107_521_107521812_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0107_521_107521812_qa_2" +description = "What is the accuracy of the decision tree classifier on the test set after feature scaling and train-test split?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0107/521/107521812.ipynb_qa_2" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "81.83" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "81.83" +QUESTION = "What is the accuracy of the decision tree classifier on the test set after feature scaling and train-test split?" +REWARD_MODE = "flexible" +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/0108_236_108236679_qa_1/instruction.md b/tasks/0108_236_108236679_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b58ce96eec320f9c6433bab15df4487fe31a1e1d --- /dev/null +++ b/tasks/0108_236_108236679_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: +How many missing values were present in the 'total_bedrooms' column before imputation? + +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_236_108236679_qa_1/task.toml b/tasks/0108_236_108236679_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1b198d2ba7c8dbe4745f95cbee2b8b93153516b2 --- /dev/null +++ b/tasks/0108_236_108236679_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0108_236_108236679_qa_1" +description = "How many missing values were present in the 'total_bedrooms' column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0108/236/108236679.ipynb_qa_1" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "207" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "207" +QUESTION = "How many missing values were present in the 'total_bedrooms' column before imputation?" +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_284_108284561_qa_2/instruction.md b/tasks/0108_284_108284561_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..27c9ed1fbb3a49209e802b5656a831799a0c93a7 --- /dev/null +++ b/tasks/0108_284_108284561_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): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many rows were removed from the dataset during outlier removal based on the total_bedrooms threshold (≥2800)? + +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_284_108284561_qa_2/task.toml b/tasks/0108_284_108284561_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1c980cc280d0feb0cc88e8631b2a9562c8ac57da --- /dev/null +++ b/tasks/0108_284_108284561_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0108_284_108284561_qa_2" +description = "How many rows were removed from the dataset during outlier removal based on the total_bedrooms threshold (≥2800)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0108/284/108284561.ipynb_qa_2" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "90" +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 = "90" +QUESTION = "How many rows were removed from the dataset during outlier removal based on the total_bedrooms threshold (≥2800)?" +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_681_108681309_qa_1/instruction.md b/tasks/0108_681_108681309_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7ea827d57b29752107ee8a8397383c8730fe5b6c --- /dev/null +++ b/tasks/0108_681_108681309_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many standard deviations above the mean are the North American sales of the top-selling game 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_681_108681309_qa_1/task.toml b/tasks/0108_681_108681309_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..04a30af3350045f0aa82cfb85c1b08d69bf06007 --- /dev/null +++ b/tasks/0108_681_108681309_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0108_681_108681309_qa_1" +description = "How many standard deviations above the mean are the North American sales of the top-selling game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0108/681/108681309.ipynb_qa_1" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "50.8" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "50.8" +QUESTION = "How many standard deviations above the mean are the North American sales of the top-selling game 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/0108_835_108835715_qa_4/instruction.md b/tasks/0108_835_108835715_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b72537d4eb7d3f6e5bffba984c61c451f2dbdf1b --- /dev/null +++ b/tasks/0108_835_108835715_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique indices are present in the Series with duplicate index 'D'? + +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_835_108835715_qa_4/task.toml b/tasks/0108_835_108835715_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5c22b7f5b2afd3a79bee9b8f10941baddd1c0854 --- /dev/null +++ b/tasks/0108_835_108835715_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0108_835_108835715_qa_4" +description = "How many unique indices are present in the Series with duplicate index 'D'?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0108/835/108835715.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "4" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "How many unique indices are present in the Series with duplicate index 'D'?" +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_269_109269793_qa_5/instruction.md b/tasks/0109_269_109269793_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9aae5f309acacf35f5e2dad7c2ad0dc119c6bdcc --- /dev/null +++ b/tasks/0109_269_109269793_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 lowest recorded global sales value 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/0109_269_109269793_qa_5/task.toml b/tasks/0109_269_109269793_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c36ef24e8cc75d1d5fdcb757d0f1f70f0253482f --- /dev/null +++ b/tasks/0109_269_109269793_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0109_269_109269793_qa_5" +description = "What is the lowest recorded global sales value in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0109/269/109269793.ipynb_qa_5" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "0.01" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.01" +QUESTION = "What is the lowest recorded global sales value 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/0110_400_110400034_qa_5/instruction.md b/tasks/0110_400_110400034_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dfc0fb4ad93128ae804ade25367bb2b643e3bccc --- /dev/null +++ b/tasks/0110_400_110400034_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): +- 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 mean house price in the original dataset before any transformations? + +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/0110_400_110400034_qa_5/task.toml b/tasks/0110_400_110400034_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cfc32ef6a1aa35ae1cb325ec97090a187ec084f7 --- /dev/null +++ b/tasks/0110_400_110400034_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0110_400_110400034_qa_5" +description = "What is the mean house price in the original dataset before any transformations?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/400/110400034.ipynb_qa_5" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "540088.1" +reward_mode_initial = "numeric" +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 = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "540088.1" +QUESTION = "What is the mean house price in the original dataset before any transformations?" +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/0110_531_110531781_qa_1/instruction.md b/tasks/0110_531_110531781_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1914dbff7c0f7b64e19505b5467a06402d06b033 --- /dev/null +++ b/tasks/0110_531_110531781_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): +- KaggleV2-May-2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest attendance rate percentage among patients with specific health conditions (hypertension, diabetes, or handicap) 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/0110_531_110531781_qa_1/task.toml b/tasks/0110_531_110531781_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e78a536c039a687a22e48040015feb957ef8fbf0 --- /dev/null +++ b/tasks/0110_531_110531781_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0110_531_110531781_qa_1" +description = "What is the highest attendance rate percentage among patients with specific health conditions (hypertension, diabetes, or handicap) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/531/110531781.ipynb_qa_1" +kaggle_dataset_name = "joniarroba/noshowappointments" +gold_answer = "82.8" +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 = "joniarroba__noshowappointments" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "joniarroba/noshowappointments" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82.8" +QUESTION = "What is the highest attendance rate percentage among patients with specific health conditions (hypertension, diabetes, or handicap) 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/0110_597_110597362_qa_1/instruction.md b/tasks/0110_597_110597362_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1862cdbbe0b8d20c78758bd1aaa192d91cf12ddf --- /dev/null +++ b/tasks/0110_597_110597362_qa_1/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): +- Reviews.csv +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many reviews have a HelpfulnessNumerator greater than their HelpfulnessDenominator? + +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/0110_597_110597362_qa_1/task.toml b/tasks/0110_597_110597362_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fbef916f631da3b0ad0781127aab3d9d61784b55 --- /dev/null +++ b/tasks/0110_597_110597362_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0110_597_110597362_qa_1" +description = "How many reviews have a HelpfulnessNumerator greater than their HelpfulnessDenominator?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/597/110597362.ipynb_qa_1" +kaggle_dataset_name = "snap/amazon-fine-food-reviews" +gold_answer = "2" +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 = "snap__amazon-fine-food-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "snap/amazon-fine-food-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "How many reviews have a HelpfulnessNumerator greater than their HelpfulnessDenominator?" +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/0110_612_110612327_qa_4/instruction.md b/tasks/0110_612_110612327_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c9af5ddc76188eb72b5b4529f662d53236ef70cd --- /dev/null +++ b/tasks/0110_612_110612327_qa_4/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): +- database.sqlite +- Reviews.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 reviews removed as duplicates during preprocessing? + +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/0110_612_110612327_qa_4/task.toml b/tasks/0110_612_110612327_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6000b0c0aadb1b5fe060b6df2adbda0bc84af4dc --- /dev/null +++ b/tasks/0110_612_110612327_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0110_612_110612327_qa_4" +description = "What is the total number of reviews removed as duplicates during preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/612/110612327.ipynb_qa_4" +kaggle_dataset_name = "snap/amazon-fine-food-reviews" +gold_answer = "174521" +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 = "snap__amazon-fine-food-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "snap/amazon-fine-food-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "174521" +QUESTION = "What is the total number of reviews removed as duplicates during preprocessing?" +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/0110_890_110890415_qa_2/instruction.md b/tasks/0110_890_110890415_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..216c646518b7c3f90d2e74103c741694c484d33c --- /dev/null +++ b/tasks/0110_890_110890415_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: +What percentage of patients who survived more than 5 years had 0 positive axillary nodes? + +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/0110_890_110890415_qa_2/task.toml b/tasks/0110_890_110890415_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0367e5a537cca28aa2d952cc73fe1df3f5a19073 --- /dev/null +++ b/tasks/0110_890_110890415_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0110_890_110890415_qa_2" +description = "What percentage of patients who survived more than 5 years had 0 positive axillary nodes?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/890/110890415.ipynb_qa_2" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "50" +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 = "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 = "50" +QUESTION = "What percentage of patients who survived more than 5 years had 0 positive axillary nodes?" +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/0110_890_110890415_qa_5/instruction.md b/tasks/0110_890_110890415_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a67733d9313f919928fded7c831803c5ea4923bf --- /dev/null +++ b/tasks/0110_890_110890415_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): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median age of patients who survived 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/0110_890_110890415_qa_5/task.toml b/tasks/0110_890_110890415_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..21d7f40b247f51e7ddadf7514bd874d3bc31ce5d --- /dev/null +++ b/tasks/0110_890_110890415_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0110_890_110890415_qa_5" +description = "What is the median age of patients who survived more than 5 years?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/890/110890415.ipynb_qa_5" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "52.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 = "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 = "52.5" +QUESTION = "What is the median age of patients who survived more than 5 years?" +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/0111_327_111327287_qa_2/instruction.md b/tasks/0111_327_111327287_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..874bac52b158ec6b8ba7d5552037fec242b54b57 --- /dev/null +++ b/tasks/0111_327_111327287_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which region has the largest population in the dataset and what percentage of the total does it represent? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, region first, percentage with one decimal and a percent sign). + +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_327_111327287_qa_2/task.toml b/tasks/0111_327_111327287_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7a74ba0a8cd6871e87a4191b821469cd26186a53 --- /dev/null +++ b/tasks/0111_327_111327287_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0111_327_111327287_qa_2" +description = "Which region has the largest population in the dataset and what percentage of the total does it represent?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0111/327/111327287.ipynb_qa_2" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "Southeast, 27.2%" +reward_mode_initial = "list" +package_tier = 3 +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Southeast, 27.2%" +QUESTION = "Which region has the largest population in the dataset and what percentage of the total does it represent?" +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_721_111721771_qa_5/instruction.md b/tasks/0111_721_111721771_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9141ff4f94d0ec33d9eb0d2878155ca6b7cdbd4a --- /dev/null +++ b/tasks/0111_721_111721771_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): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset has the strongest positive correlation with 'median_house_value'? + +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_721_111721771_qa_5/task.toml b/tasks/0111_721_111721771_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0a3a8e75675efa1c6e4f08ad67dbee0e4a55507c --- /dev/null +++ b/tasks/0111_721_111721771_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0111_721_111721771_qa_5" +description = "Which feature in the dataset has the strongest positive correlation with 'median_house_value'?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0111/721/111721771.ipynb_qa_5" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "median_income" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "median_income" +QUESTION = "Which feature in the dataset has the strongest positive correlation with 'median_house_value'?" +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/0111_889_111889874_qa_3/instruction.md b/tasks/0111_889_111889874_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c31645d1608958e5518453064e6c4d65a61a6dac --- /dev/null +++ b/tasks/0111_889_111889874_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total global sales figure for the top-selling video game 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_889_111889874_qa_3/task.toml b/tasks/0111_889_111889874_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..34f64293468268a1a442cd5f2654fcfc267a5b59 --- /dev/null +++ b/tasks/0111_889_111889874_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0111_889_111889874_qa_3" +description = "What is the total global sales figure for the top-selling video game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0111/889/111889874.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "82.74" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82.74" +QUESTION = "What is the total global sales figure for the top-selling video game 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/0112_515_112515781_qa_1/instruction.md b/tasks/0112_515_112515781_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d619aacb524bd87c577e5383281dad9b24094906 --- /dev/null +++ b/tasks/0112_515_112515781_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of diamonds in the dataset are categorized as "Premium" quality cut? + +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/0112_515_112515781_qa_1/task.toml b/tasks/0112_515_112515781_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..29dea51f5612c27e4bfda305a28f5333deb9fff7 --- /dev/null +++ b/tasks/0112_515_112515781_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0112_515_112515781_qa_1" +description = "What percentage of diamonds in the dataset are categorized as \"Premium\" quality cut?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0112/515/112515781.ipynb_qa_1" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "25.6" +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "25.6" +QUESTION = "What percentage of diamonds in the dataset are categorized as \"Premium\" quality cut?" +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/0112_857_112857611_qa_5/instruction.md b/tasks/0112_857_112857611_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..02308159c20f283bd9d7e27b3a0d12a2aa7968c9 --- /dev/null +++ b/tasks/0112_857_112857611_qa_5/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between the battery_power feature and price_range after all feature engineering steps? + +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/0112_857_112857611_qa_5/task.toml b/tasks/0112_857_112857611_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c190a1c855744b2e9e7d8a276cbad15c8e805c54 --- /dev/null +++ b/tasks/0112_857_112857611_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0112_857_112857611_qa_5" +description = "What is the correlation coefficient between the battery_power feature and price_range after all feature engineering steps?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0112/857/112857611.ipynb_qa_5" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "0.200723" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.200723" +QUESTION = "What is the correlation coefficient between the battery_power feature and price_range after all feature engineering steps?" +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/0113_124_113124981_qa_5/instruction.md b/tasks/0113_124_113124981_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e0ac48e63b6efd0e87df85139d7510c105473857 --- /dev/null +++ b/tasks/0113_124_113124981_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): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the median value of the 'total_bedrooms' column used for imputing missing 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/0113_124_113124981_qa_5/task.toml b/tasks/0113_124_113124981_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..80b389357601143fd0fd7b7e4865eaecaa9dc698 --- /dev/null +++ b/tasks/0113_124_113124981_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0113_124_113124981_qa_5" +description = "What was the median value of the 'total_bedrooms' column used for imputing missing values in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0113/124/113124981.ipynb_qa_5" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "435.0" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "435.0" +QUESTION = "What was the median value of the 'total_bedrooms' column used for imputing missing values 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/0113_167_113167723_qa_2/instruction.md b/tasks/0113_167_113167723_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..16bab9834add7db37d59b3587f13a52ff81a3090 --- /dev/null +++ b/tasks/0113_167_113167723_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many duplicate rows were identified and removed from 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/0113_167_113167723_qa_2/task.toml b/tasks/0113_167_113167723_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..808fce2150706c02e840734bcb7f257f5a60ffd0 --- /dev/null +++ b/tasks/0113_167_113167723_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0113_167_113167723_qa_2" +description = "How many duplicate rows were identified and removed from the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0113/167/113167723.ipynb_qa_2" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "1" +reward_mode_initial = "numeric" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "How many duplicate rows were identified and removed from 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/0113_504_113504478_qa_5/instruction.md b/tasks/0113_504_113504478_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..12cd1f8c3895144b0389f31914240934fa9fccfd --- /dev/null +++ b/tasks/0113_504_113504478_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): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Based on the distribution analysis, do malignant tumors tend to have higher concave points mean values compared to benign tumors? + +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/0113_504_113504478_qa_5/task.toml b/tasks/0113_504_113504478_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5251953471010d8315baf44fd946d9352d3296a9 --- /dev/null +++ b/tasks/0113_504_113504478_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0113_504_113504478_qa_5" +description = "Based on the distribution analysis, do malignant tumors tend to have higher concave points mean values compared to benign tumors?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0113/504/113504478.ipynb_qa_5" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +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__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 = "yes" +QUESTION = "Based on the distribution analysis, do malignant tumors tend to have higher concave points mean values compared to benign tumors?" +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/0113_777_113777393_qa_2/instruction.md b/tasks/0113_777_113777393_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6f1fd9698a4400084f010afab96c4eb33e7a4b2a --- /dev/null +++ b/tasks/0113_777_113777393_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: +What is the original Petal Length value corresponding to the 75th percentile of the normalized Petal Length 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/0113_777_113777393_qa_2/task.toml b/tasks/0113_777_113777393_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6b0aafd8d6b27c4927084b6ec8a3fddc22984bfc --- /dev/null +++ b/tasks/0113_777_113777393_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0113_777_113777393_qa_2" +description = "What is the original Petal Length value corresponding to the 75th percentile of the normalized Petal Length distribution?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0113/777/113777393.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "5.1" +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 = "5.1" +QUESTION = "What is the original Petal Length value corresponding to the 75th percentile of the normalized Petal Length 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/0113_777_113777393_qa_5/instruction.md b/tasks/0113_777_113777393_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bd4a5a5055486d760dd4020597ea6bc7e59402b3 --- /dev/null +++ b/tasks/0113_777_113777393_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): +- Iris.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 original Petal Width? + +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/0113_777_113777393_qa_5/task.toml b/tasks/0113_777_113777393_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4ab2d01e6c55b36b8e244ab360c2f5228240e4ce --- /dev/null +++ b/tasks/0113_777_113777393_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0113_777_113777393_qa_5" +description = "What is the standard deviation of the original Petal Width?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0113/777/113777393.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.763161" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.763161" +QUESTION = "What is the standard deviation of the original Petal Width?" +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/0113_929_113929776_qa_3/instruction.md b/tasks/0113_929_113929776_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..41da1f890fed79eee8beec846c86fca539a0a05f --- /dev/null +++ b/tasks/0113_929_113929776_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the R-squared score achieved by the XGBoost regression model on the test 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/0113_929_113929776_qa_3/task.toml b/tasks/0113_929_113929776_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8f8680f964efa929022444ad0901d554a66aa566 --- /dev/null +++ b/tasks/0113_929_113929776_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0113_929_113929776_qa_3" +description = "What is the R-squared score achieved by the XGBoost regression model on the test dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0113/929/113929776.ipynb_qa_3" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "0.9820448935367375" +reward_mode_initial = "numeric" +package_tier = 2 +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.9820448935367375" +QUESTION = "What is the R-squared score achieved by the XGBoost regression model on the test 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/0114_091_114091161_qa_3/instruction.md b/tasks/0114_091_114091161_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3dea9a81c249fcb3c4f1a6b5282031e976d9f57f --- /dev/null +++ b/tasks/0114_091_114091161_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average global sales for Nintendo Wii games compared to the average global sales of all other platforms (as a multiplier)? + +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/0114_091_114091161_qa_3/task.toml b/tasks/0114_091_114091161_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..63769778e1d72dc0835bc0c5c88e490e4defd97d --- /dev/null +++ b/tasks/0114_091_114091161_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0114_091_114091161_qa_3" +description = "What is the average global sales for Nintendo Wii games compared to the average global sales of all other platforms (as a multiplier)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0114/091/114091161.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "1.336" +reward_mode_initial = "numeric" +package_tier = 3 +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 = "1.336" +QUESTION = "What is the average global sales for Nintendo Wii games compared to the average global sales of all other platforms (as a multiplier)?" +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/0114_908_114908217_qa_4/instruction.md b/tasks/0114_908_114908217_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..abb3981e1c4ee595ba9469fc220e90a2e16c4272 --- /dev/null +++ b/tasks/0114_908_114908217_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the lowest price of any diamond 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/0114_908_114908217_qa_4/task.toml b/tasks/0114_908_114908217_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..383f447bbc072646dde253a3b921213ec11d3424 --- /dev/null +++ b/tasks/0114_908_114908217_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0114_908_114908217_qa_4" +description = "What is the lowest price of any diamond in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0114/908/114908217.ipynb_qa_4" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "326" +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "326" +QUESTION = "What is the lowest price of any diamond 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/0115_266_115266605_qa_3/instruction.md b/tasks/0115_266_115266605_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f427f78d90b23cd765d08f35b6e630f850f3f2c0 --- /dev/null +++ b/tasks/0115_266_115266605_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): +- vgsales.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 global sales for all games 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/0115_266_115266605_qa_3/task.toml b/tasks/0115_266_115266605_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a1f0779927902879a6f8f6d8533df24ddc04c249 --- /dev/null +++ b/tasks/0115_266_115266605_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0115_266_115266605_qa_3" +description = "What is the median value of global sales for all games in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0115/266/115266605.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "0.17" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.17" +QUESTION = "What is the median value of global sales for all games 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/0115_266_115266605_qa_4/instruction.md b/tasks/0115_266_115266605_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..54726e716e40a15f82b36a2fa311d9d4511d1e35 --- /dev/null +++ b/tasks/0115_266_115266605_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest global sales value recorded for any game 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/0115_266_115266605_qa_4/task.toml b/tasks/0115_266_115266605_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fd4a361eea877f6ae590491494b41b3327fb1773 --- /dev/null +++ b/tasks/0115_266_115266605_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0115_266_115266605_qa_4" +description = "What is the highest global sales value recorded for any game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0115/266/115266605.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "82.74" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82.74" +QUESTION = "What is the highest global sales value recorded for any game 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/0115_532_115532151_qa_3/instruction.md b/tasks/0115_532_115532151_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4f8763e46269cf33b198623b5d8535b7268da215 --- /dev/null +++ b/tasks/0115_532_115532151_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): +- breast-cancer-wisconsin.data.txt + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average cross-validation accuracy of the KNN model using 10-fold cross-validation? + +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/0115_532_115532151_qa_3/task.toml b/tasks/0115_532_115532151_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8701e938cac725287b87e7ce6a1fffd80d34ef82 --- /dev/null +++ b/tasks/0115_532_115532151_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0115_532_115532151_qa_3" +description = "What is the average cross-validation accuracy of the KNN model using 10-fold cross-validation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0115/532/115532151.ipynb_qa_3" +kaggle_dataset_name = "zzero0/uci-breast-cancer-wisconsin-original" +gold_answer = "0.9672" +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 = "zzero0__uci-breast-cancer-wisconsin-original" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zzero0/uci-breast-cancer-wisconsin-original" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.9672" +QUESTION = "What is the average cross-validation accuracy of the KNN model using 10-fold cross-validation?" +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/0115_943_115943948_qa_3/instruction.md b/tasks/0115_943_115943948_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fc34d15cf5f0710e7ff6f94db763078fc286a988 --- /dev/null +++ b/tasks/0115_943_115943948_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): +- 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 positive correlation coefficient between any two variables in 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/0115_943_115943948_qa_3/task.toml b/tasks/0115_943_115943948_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8569ebb311c6ca950b5d4140a0fc52ab3599b759 --- /dev/null +++ b/tasks/0115_943_115943948_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0115_943_115943948_qa_3" +description = "What is the highest positive correlation coefficient between any two variables in the correlation matrix?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0115/943/115943948.ipynb_qa_3" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "0.67" +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__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 = "0.67" +QUESTION = "What is the highest positive correlation coefficient between any two variables in the correlation matrix?" +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/0115_972_115972863_qa_1/instruction.md b/tasks/0115_972_115972863_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..318eff67998db28d86dddf0ac9aaee398e591b51 --- /dev/null +++ b/tasks/0115_972_115972863_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many records remain in the dataset after removing rows with zero values in BMI, Glucose, and BloodPressure columns? + +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/0115_972_115972863_qa_1/task.toml b/tasks/0115_972_115972863_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a8da70aa97445cf4098b4f4a07eb2366d6ee3e37 --- /dev/null +++ b/tasks/0115_972_115972863_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0115_972_115972863_qa_1" +description = "How many records remain in the dataset after removing rows with zero values in BMI, Glucose, and BloodPressure columns?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0115/972/115972863.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "724" +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 = "724" +QUESTION = "How many records remain in the dataset after removing rows with zero values in BMI, Glucose, and BloodPressure columns?" +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/0116_026_116026387_qa_3/instruction.md b/tasks/0116_026_116026387_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e0c101801b08ffb0ae8bc89278c030bddb3af1ef --- /dev/null +++ b/tasks/0116_026_116026387_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): +- HR_comma_sep.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which department has the highest number of employees who left the company? + +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_026_116026387_qa_3/task.toml b/tasks/0116_026_116026387_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e1e3b94ccf02ea1880c6de20155ad6d1621b81c9 --- /dev/null +++ b/tasks/0116_026_116026387_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0116_026_116026387_qa_3" +description = "Which department has the highest number of employees who left the company?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0116/026/116026387.ipynb_qa_3" +kaggle_dataset_name = "giripujar/hr-analytics" +gold_answer = "Sales" +reward_mode_initial = "exact_short" +package_tier = 3 +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 = "giripujar__hr-analytics" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "giripujar/hr-analytics" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Sales" +QUESTION = "Which department has the highest number of employees who left the company?" +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/0116_418_116418769_qa_3/instruction.md b/tasks/0116_418_116418769_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c6f0727ba4c199170e72fd9d2d2648d1ffdb9e02 --- /dev/null +++ b/tasks/0116_418_116418769_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many customers in the dataset churned (Churn=Yes) after removing rows with missing TotalCharges 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_418_116418769_qa_3/task.toml b/tasks/0116_418_116418769_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7fd88865d661875b1f23558701ec2f04aae6338c --- /dev/null +++ b/tasks/0116_418_116418769_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0116_418_116418769_qa_3" +description = "How many customers in the dataset churned (Churn=Yes) after removing rows with missing TotalCharges values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0116/418/116418769.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "1869" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1869" +QUESTION = "How many customers in the dataset churned (Churn=Yes) after removing rows with missing TotalCharges values?" +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/0116_418_116418769_qa_4/instruction.md b/tasks/0116_418_116418769_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..41b2d0d37ba5e5ef81a5bbb692cb0a93e1efcf21 --- /dev/null +++ b/tasks/0116_418_116418769_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the number of rows removed from the dataset due to missing values in the TotalCharges column? + +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_418_116418769_qa_4/task.toml b/tasks/0116_418_116418769_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..03f152fa01d25719aa67a30c6307eba1ef304d8d --- /dev/null +++ b/tasks/0116_418_116418769_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0116_418_116418769_qa_4" +description = "What is the number of rows removed from the dataset due to missing values in the TotalCharges column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0116/418/116418769.ipynb_qa_4" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "11" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11" +QUESTION = "What is the number of rows removed from the dataset due to missing values in the TotalCharges column?" +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/0116_898_116898391_qa_3/instruction.md b/tasks/0116_898_116898391_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e404b68e21eee1166b9df9c4d584ed260bbcc289 --- /dev/null +++ b/tasks/0116_898_116898391_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average house 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/0116_898_116898391_qa_3/task.toml b/tasks/0116_898_116898391_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ec50051ccef85b83355688104da790ca582af155 --- /dev/null +++ b/tasks/0116_898_116898391_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0116_898_116898391_qa_3" +description = "What is the average house price in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0116/898/116898391.ipynb_qa_3" +kaggle_dataset_name = "vedavyasv/usa-housing" +gold_answer = "1232073.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 = "vedavyasv__usa-housing" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vedavyasv/usa-housing" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1232073.0" +QUESTION = "What is the average house price in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +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/0117_621_117621488_qa_2/instruction.md b/tasks/0117_621_117621488_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..07c9d631ba1821b670a43533d087aafa552558aa --- /dev/null +++ b/tasks/0117_621_117621488_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 percentage of the dataset corresponds to malignant (M) tumor diagnoses? + +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/0117_621_117621488_qa_2/task.toml b/tasks/0117_621_117621488_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..137aa61a074d6358428e3204a6e634971c9b43bd --- /dev/null +++ b/tasks/0117_621_117621488_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0117_621_117621488_qa_2" +description = "What percentage of the dataset corresponds to malignant (M) tumor diagnoses?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0117/621/117621488.ipynb_qa_2" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "37.26" +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__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 = "37.26" +QUESTION = "What percentage of the dataset corresponds to malignant (M) tumor diagnoses?" +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/0118_088_118088123_qa_1/instruction.md b/tasks/0118_088_118088123_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7e4258f2a69db4273d721602ba9a11faab704b9e --- /dev/null +++ b/tasks/0118_088_118088123_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 percentage of the dataset consists of wines with the highest quality rating of 8? + +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/0118_088_118088123_qa_1/task.toml b/tasks/0118_088_118088123_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f8f627725853d3bf3c7e90fcb35c27762f7ed245 --- /dev/null +++ b/tasks/0118_088_118088123_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0118_088_118088123_qa_1" +description = "What percentage of the dataset consists of wines with the highest quality rating of 8?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0118/088/118088123.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "1.125704" +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__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 = "1.125704" +QUESTION = "What percentage of the dataset consists of wines with the highest quality rating of 8?" +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/0119_001_119001162_qa_4/instruction.md b/tasks/0119_001_119001162_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..547bd0459c92af6224cd5e61c344cf5eddeb9c6f --- /dev/null +++ b/tasks/0119_001_119001162_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What marital status category has the highest proportion of individuals with income greater than 50K? + +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_001_119001162_qa_4/task.toml b/tasks/0119_001_119001162_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a9a64e22505d3f45da97d64583d002573d5c2336 --- /dev/null +++ b/tasks/0119_001_119001162_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0119_001_119001162_qa_4" +description = "What marital status category has the highest proportion of individuals with income greater than 50K?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0119/001/119001162.ipynb_qa_4" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "Married-civ-spouse" +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__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Married-civ-spouse" +QUESTION = "What marital status category has the highest proportion of individuals with income greater than 50K?" +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/0119_277_119277434_qa_4/instruction.md b/tasks/0119_277_119277434_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b5a1ae2c2b9909f0f4eb02f4beae02b3eca800ff --- /dev/null +++ b/tasks/0119_277_119277434_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average global sales value across all video games 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_277_119277434_qa_4/task.toml b/tasks/0119_277_119277434_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1232a45f2dc11d93eddf234d8e54c9d3a3c64fc1 --- /dev/null +++ b/tasks/0119_277_119277434_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0119_277_119277434_qa_4" +description = "What is the average global sales value across all video games in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0119/277/119277434.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "0.537441" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.537441" +QUESTION = "What is the average global sales value across all video games 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/0119_926_119926274_qa_5/instruction.md b/tasks/0119_926_119926274_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..01b89f8db6b034cbb28f733b59f20039bddc53ba --- /dev/null +++ b/tasks/0119_926_119926274_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): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the shape of the matrix used in the manual prediction calculation for the first test sample? + +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_926_119926274_qa_5/task.toml b/tasks/0119_926_119926274_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4ddb5f47218f3df9ab347f10dad682c91374ab6d --- /dev/null +++ b/tasks/0119_926_119926274_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0119_926_119926274_qa_5" +description = "What is the shape of the matrix used in the manual prediction calculation for the first test sample?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0119/926/119926274.ipynb_qa_5" +kaggle_dataset_name = "schirmerchad/bostonhoustingmlnd" +gold_answer = "(1, 4)" +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 = "schirmerchad__bostonhoustingmlnd" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "schirmerchad/bostonhoustingmlnd" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "(1, 4)" +QUESTION = "What is the shape of the matrix used in the manual prediction calculation for the first test sample?" +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/0119_986_119986677_qa_3/instruction.md b/tasks/0119_986_119986677_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fb5935e618bdbea17838d127d1d57f2be5c40cad --- /dev/null +++ b/tasks/0119_986_119986677_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which video game was sold the most times (highest count of entries) across all regions? + +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_986_119986677_qa_3/task.toml b/tasks/0119_986_119986677_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..eedb87e295ab5d068b3920495a8c9310cbbd747f --- /dev/null +++ b/tasks/0119_986_119986677_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0119_986_119986677_qa_3" +description = "Which video game was sold the most times (highest count of entries) across all regions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0119/986/119986677.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Need for Speed: Most Wanted" +reward_mode_initial = "exact_short" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Need for Speed: Most Wanted" +QUESTION = "Which video game was sold the most times (highest count of entries) across all regions?" +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/0120_525_120525884_qa_4/instruction.md b/tasks/0120_525_120525884_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6965150f7967a32607778bc3e3d1750489aecddd --- /dev/null +++ b/tasks/0120_525_120525884_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): +- Womens Clothing E-Commerce Reviews.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average cross-validation score of the XGBoost model when using only the 'recommended_ind' feature? + +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/0120_525_120525884_qa_4/task.toml b/tasks/0120_525_120525884_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c5ba1b9d172a9d4937730f00e859c99a04fc644d --- /dev/null +++ b/tasks/0120_525_120525884_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0120_525_120525884_qa_4" +description = "What is the average cross-validation score of the XGBoost model when using only the 'recommended_ind' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0120/525/120525884.ipynb_qa_4" +kaggle_dataset_name = "nicapotato/womens-ecommerce-clothing-reviews" +gold_answer = "0.6265320368095288" +reward_mode_initial = "numeric" +package_tier = 2 +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 = "nicapotato__womens-ecommerce-clothing-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nicapotato/womens-ecommerce-clothing-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.6265320368095288" +QUESTION = "What is the average cross-validation score of the XGBoost model when using only the 'recommended_ind' feature?" +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/0120_687_120687537_qa_5/instruction.md b/tasks/0120_687_120687537_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..97bbe43d85ed4a0ba3b118abb8ef2b4b0c0c990f --- /dev/null +++ b/tasks/0120_687_120687537_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): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average value of the median_income across all samples 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/0120_687_120687537_qa_5/task.toml b/tasks/0120_687_120687537_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4a297f6cfcc098c7cac3147bc5f2c32df7a540e7 --- /dev/null +++ b/tasks/0120_687_120687537_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0120_687_120687537_qa_5" +description = "What is the average value of the median_income across all samples in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0120/687/120687537.ipynb_qa_5" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "3.870671" +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 = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3.870671" +QUESTION = "What is the average value of the median_income across all samples 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/0121_143_121143084_qa_3/instruction.md b/tasks/0121_143_121143084_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..983cdaffcc82ca84fa9c347f882ef7c0478ec986 --- /dev/null +++ b/tasks/0121_143_121143084_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): +- GlobalTemperatures.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the critical value at 5% significance level from the ADF test that determines stationarity of the original temperature 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/0121_143_121143084_qa_3/task.toml b/tasks/0121_143_121143084_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e569098de6f7947741b59935fb6229382d51fc67 --- /dev/null +++ b/tasks/0121_143_121143084_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0121_143_121143084_qa_3" +description = "What is the critical value at 5% significance level from the ADF test that determines stationarity of the original temperature data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0121/143/121143084.ipynb_qa_3" +kaggle_dataset_name = "berkeleyearth/climate-change-earth-surface-temperature-data" +gold_answer = "-2.8631" +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 = "berkeleyearth__climate-change-earth-surface-temperature-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "berkeleyearth/climate-change-earth-surface-temperature-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "-2.8631" +QUESTION = "What is the critical value at 5% significance level from the ADF test that determines stationarity of the original temperature data?" +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/0121_209_121209389_qa_1/instruction.md b/tasks/0121_209_121209389_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1efc56a631c55e2397924d1f5247a21d37c5fe55 --- /dev/null +++ b/tasks/0121_209_121209389_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): +- car_evaluation.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which model (Gini or Entropy) achieved higher accuracy 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/0121_209_121209389_qa_1/task.toml b/tasks/0121_209_121209389_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fbbd5dd3fcc58a99f1f1ae6feb9032d7f0bc5dd0 --- /dev/null +++ b/tasks/0121_209_121209389_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0121_209_121209389_qa_1" +description = "Which model (Gini or Entropy) achieved higher accuracy on the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0121/209/121209389.ipynb_qa_1" +kaggle_dataset_name = "elikplim/car-evaluation-data-set" +gold_answer = "Entropy" +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 = "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 = "Entropy" +QUESTION = "Which model (Gini or Entropy) achieved higher accuracy on the test set?" +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/0121_947_121947601_qa_1/instruction.md b/tasks/0121_947_121947601_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..872d09cc690def9515deeaf39bc16a8418ce6f70 --- /dev/null +++ b/tasks/0121_947_121947601_qa_1/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): +- german_credit_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of missing values in the dataset before imputation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a percentage (e.g. 95.5), not a fraction. + +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/0121_947_121947601_qa_1/task.toml b/tasks/0121_947_121947601_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f201ebaf782db6aedc5c4865c74ff0801c590186 --- /dev/null +++ b/tasks/0121_947_121947601_qa_1/task.toml @@ -0,0 +1,58 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0121_947_121947601_qa_1" +description = "What is the percentage of missing values in the dataset before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0121/947/121947601.ipynb_qa_1" +kaggle_dataset_name = "kabure/german-credit-data-with-risk" +gold_answer = "5.245%" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +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 = "kabure__german-credit-data-with-risk" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kabure/german-credit-data-with-risk" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5.245%" +QUESTION = "What is the percentage of missing values in the dataset before imputation?" +REWARD_MODE = "flexible" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0121_988_121988886_qa_5/instruction.md b/tasks/0121_988_121988886_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..516a5330976727d9fc555e1abbcc6f64b143cc15 --- /dev/null +++ b/tasks/0121_988_121988886_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which cluster produced by the K-Means algorithm has the largest number of data points? + +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/0121_988_121988886_qa_5/task.toml b/tasks/0121_988_121988886_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e5e90a518088bc7b9c2cb4ccdfc6db01001ea96b --- /dev/null +++ b/tasks/0121_988_121988886_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0121_988_121988886_qa_5" +description = "Which cluster produced by the K-Means algorithm has the largest number of data points?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0121/988/121988886.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0" +reward_mode_initial = "exact_short" +package_tier = 3 +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "Which cluster produced by the K-Means algorithm has the largest number of data points?" +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/0122_097_122097207_qa_1/instruction.md b/tasks/0122_097_122097207_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..080a523097bf44a8dcdf77bf8c0325dffe59a239 --- /dev/null +++ b/tasks/0122_097_122097207_qa_1/instruction.md @@ -0,0 +1,18 @@ +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 +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the distribution of the 'price_range' target variable in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the four counts, in the order they appear. + +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/0122_097_122097207_qa_1/task.toml b/tasks/0122_097_122097207_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d05029ca34dcd500d9001224eb320bfcd62305d8 --- /dev/null +++ b/tasks/0122_097_122097207_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0122_097_122097207_qa_1" +description = "What is the distribution of the 'price_range' target variable in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0122/097/122097207.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "500,500,500,500" +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 = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "500,500,500,500" +QUESTION = "What is the distribution of the 'price_range' target variable in the dataset?" +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/0122_394_122394666_qa_1/instruction.md b/tasks/0122_394_122394666_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..240bffff35f75532671eef5e292914bf3b172bec --- /dev/null +++ b/tasks/0122_394_122394666_qa_1/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the Pearson correlation coefficient between x and y 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/0122_394_122394666_qa_1/task.toml b/tasks/0122_394_122394666_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f20c47ee90a0d6299608201259e89edcab136178 --- /dev/null +++ b/tasks/0122_394_122394666_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0122_394_122394666_qa_1" +description = "What is the Pearson correlation coefficient between x and y in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0122/394/122394666.ipynb_qa_1" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "0.9953" +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 = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.9953" +QUESTION = "What is the Pearson correlation coefficient between x and y 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/0122_517_122517438_qa_3/instruction.md b/tasks/0122_517_122517438_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..037fe78bbdf8c7100baa6a207f8b891110a36fe7 --- /dev/null +++ b/tasks/0122_517_122517438_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: +What is the test accuracy achieved by the KNN model using K=9? + +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/0122_517_122517438_qa_3/task.toml b/tasks/0122_517_122517438_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2071c00570338c3c35f028684dd479507c99bddb --- /dev/null +++ b/tasks/0122_517_122517438_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0122_517_122517438_qa_3" +description = "What is the test accuracy achieved by the KNN model using K=9?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0122/517/122517438.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.9649122807017544" +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 = "0.9649122807017544" +QUESTION = "What is the test accuracy achieved by the KNN model using K=9?" +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/0123_169_123169310_qa_3/instruction.md b/tasks/0123_169_123169310_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bf54c68a58e27ef621c39808d024c877fd47b236 --- /dev/null +++ b/tasks/0123_169_123169310_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many entries in the Year column have missing (null) 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/0123_169_123169310_qa_3/task.toml b/tasks/0123_169_123169310_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2adc522dbcb1c21fff0adc3092e56dd955064ecf --- /dev/null +++ b/tasks/0123_169_123169310_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0123_169_123169310_qa_3" +description = "How many entries in the Year column have missing (null) values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0123/169/123169310.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "271" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "271" +QUESTION = "How many entries in the Year column have missing (null) values?" +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/0123_343_123343619_qa_2/instruction.md b/tasks/0123_343_123343619_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..280a049493fc0e1fd5de9b37bc180bb8e2ce9a8b --- /dev/null +++ b/tasks/0123_343_123343619_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 who survived (Survival=1) have more than the upper whisker threshold in the number of positive axillary nodes? + +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/0123_343_123343619_qa_2/task.toml b/tasks/0123_343_123343619_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2e904ed458f9d050a1356ff691ced1bf6a84d5c7 --- /dev/null +++ b/tasks/0123_343_123343619_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0123_343_123343619_qa_2" +description = "How many patients who survived (Survival=1) have more than the upper whisker threshold in the number of positive axillary nodes?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0123/343/123343619.ipynb_qa_2" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "26" +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 = "26" +QUESTION = "How many patients who survived (Survival=1) have more than the upper whisker threshold in the number of positive axillary nodes?" +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/0123_452_123452071_qa_4/instruction.md b/tasks/0123_452_123452071_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..81e41af98b7cb0eb303b282f1724b2bcb2553bc1 --- /dev/null +++ b/tasks/0123_452_123452071_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): +- CC GENERAL.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 `MINIMUM_PAYMENTS` column before imputation? + +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/0123_452_123452071_qa_4/task.toml b/tasks/0123_452_123452071_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..186df8853274518460b1e811c8abd4518b1169db --- /dev/null +++ b/tasks/0123_452_123452071_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0123_452_123452071_qa_4" +description = "How many missing values were present in the `MINIMUM_PAYMENTS` column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0123/452/123452071.ipynb_qa_4" +kaggle_dataset_name = "arjunbhasin2013/ccdata" +gold_answer = "313" +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 = "arjunbhasin2013__ccdata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arjunbhasin2013/ccdata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "313" +QUESTION = "How many missing values were present in the `MINIMUM_PAYMENTS` column before imputation?" +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/0123_500_123500011_qa_2/instruction.md b/tasks/0123_500_123500011_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7a71fd140d0ed72228a0865d6c13871a12f6d06d --- /dev/null +++ b/tasks/0123_500_123500011_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): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Pokémon type has the highest number of Pokémon in the dataset, and how many Pokémon belong to that type? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: type with Pokémon. + +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/0123_500_123500011_qa_2/task.toml b/tasks/0123_500_123500011_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e53edc5bdb6c5eb7c3827fc84073aac0b3461ce0 --- /dev/null +++ b/tasks/0123_500_123500011_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0123_500_123500011_qa_2" +description = "Which Pokémon type has the highest number of Pokémon in the dataset, and how many Pokémon belong to that type?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0123/500/123500011.ipynb_qa_2" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "Water type with 112 Pokémon." +reward_mode_initial = "flexible" +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 = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Water type with 112 Pokémon." +QUESTION = "Which Pokémon type has the highest number of Pokémon in the dataset, and how many Pokémon belong to that type?" +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/0123_500_123500011_qa_5/instruction.md b/tasks/0123_500_123500011_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4c55cec7e18f3b43153c9338decccf9389f332cc --- /dev/null +++ b/tasks/0123_500_123500011_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): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique primary types (Type 1) are present 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/0123_500_123500011_qa_5/task.toml b/tasks/0123_500_123500011_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f2fb2be4e6e2e98c47e23153954a82a93f02dd42 --- /dev/null +++ b/tasks/0123_500_123500011_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0123_500_123500011_qa_5" +description = "How many unique primary types (Type 1) are present in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0123/500/123500011.ipynb_qa_5" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "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 = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "18" +QUESTION = "How many unique primary types (Type 1) are present 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/0123_735_123735039_qa_5/instruction.md b/tasks/0123_735_123735039_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f377bd70ae05b4eee362b1da24542a3670091346 --- /dev/null +++ b/tasks/0123_735_123735039_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: +Which publisher has the highest number of games listed 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/0123_735_123735039_qa_5/task.toml b/tasks/0123_735_123735039_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..20e83be2a7766af4a75cdeacfe819ba75d72a2ab --- /dev/null +++ b/tasks/0123_735_123735039_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0123_735_123735039_qa_5" +description = "Which publisher has the highest number of games listed in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0123/735/123735039.ipynb_qa_5" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Electronic Arts" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Electronic Arts" +QUESTION = "Which publisher has the highest number of games listed 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/0124_195_124195561_qa_1/instruction.md b/tasks/0124_195_124195561_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b1604b7a7befb09bbc3c38bad771e41ab0a9de6d --- /dev/null +++ b/tasks/0124_195_124195561_qa_1/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): +- oasis_cross-sectional.csv +- oasis_longitudinal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of subjects in the final merged dataset classified as having Alzheimer's disease (Demented) after data preprocessing? + +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/0124_195_124195561_qa_1/task.toml b/tasks/0124_195_124195561_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7d150d8acc2e2ed01d49adc50850ea95047ae63d --- /dev/null +++ b/tasks/0124_195_124195561_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0124_195_124195561_qa_1" +description = "What is the percentage of subjects in the final merged dataset classified as having Alzheimer's disease (Demented) after data preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0124/195/124195561.ipynb_qa_1" +kaggle_dataset_name = "jboysen/mri-and-alzheimers" +gold_answer = "39.14" +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 = "jboysen__mri-and-alzheimers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "jboysen/mri-and-alzheimers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "39.14" +QUESTION = "What is the percentage of subjects in the final merged dataset classified as having Alzheimer's disease (Demented) after data preprocessing?" +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/0124_334_124334340_qa_4/instruction.md b/tasks/0124_334_124334340_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..201b46287db746c407d222747928ab5e643486ac --- /dev/null +++ b/tasks/0124_334_124334340_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 percentage of the 'market_category' column contained missing values in the original dataset before any imputation? + +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/0124_334_124334340_qa_4/task.toml b/tasks/0124_334_124334340_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..95d1349a0b7f4c0b14b9ae679e48fc9d52cbef3d --- /dev/null +++ b/tasks/0124_334_124334340_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0124_334_124334340_qa_4" +description = "What percentage of the 'market_category' column contained missing values in the original dataset before any imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0124/334/124334340.ipynb_qa_4" +kaggle_dataset_name = "CooperUnion/cardataset" +gold_answer = "31.41" +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 = "CooperUnion__cardataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "CooperUnion/cardataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "31.41" +QUESTION = "What percentage of the 'market_category' column contained missing values in the original dataset before any imputation?" +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/0124_739_124739657_qa_1/instruction.md b/tasks/0124_739_124739657_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b87e7d1d6945191b61d0ec380adec6045afc94ae --- /dev/null +++ b/tasks/0124_739_124739657_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest total sales figure for any game 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/0124_739_124739657_qa_1/task.toml b/tasks/0124_739_124739657_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d56c4e4af19ae6d7496e7ad95670ef0209862160 --- /dev/null +++ b/tasks/0124_739_124739657_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0124_739_124739657_qa_1" +description = "What is the highest total sales figure for any game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0124/739/124739657.ipynb_qa_1" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "82.74" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82.74" +QUESTION = "What is the highest total sales figure for any game 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/0124_966_124966489_qa_1/instruction.md b/tasks/0124_966_124966489_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..44150677d088b01d85f0a250165e130754de55c1 --- /dev/null +++ b/tasks/0124_966_124966489_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): +- melb_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which property type (Type) has the highest number of entries 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/0124_966_124966489_qa_1/task.toml b/tasks/0124_966_124966489_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f6f099fb9b1ef36d8679f33c25f292bee3ac832c --- /dev/null +++ b/tasks/0124_966_124966489_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0124_966_124966489_qa_1" +description = "Which property type (Type) has the highest number of entries in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0124/966/124966489.ipynb_qa_1" +kaggle_dataset_name = "gunjanpathak/melb-data" +gold_answer = "h" +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 = "gunjanpathak__melb-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gunjanpathak/melb-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "h" +QUESTION = "Which property type (Type) has the highest number of entries 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_379_125379106_qa_1/instruction.md b/tasks/0125_379_125379106_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..be7b3de0c5b571991a13df5eb2f558dec256aba8 --- /dev/null +++ b/tasks/0125_379_125379106_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: +What is the average insurance charge for smokers 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_379_125379106_qa_1/task.toml b/tasks/0125_379_125379106_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..307ff1e4067104deb43df6d68026dd2b407282c9 --- /dev/null +++ b/tasks/0125_379_125379106_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0125_379_125379106_qa_1" +description = "What is the average insurance charge for smokers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0125/379/125379106.ipynb_qa_1" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "32050.23" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "32050.23" +QUESTION = "What is the average insurance charge for smokers 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/0125_537_125537786_qa_2/instruction.md b/tasks/0125_537_125537786_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..78457e4707e44ff7da929a96c650459c6b33a0d8 --- /dev/null +++ b/tasks/0125_537_125537786_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): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average tenure (in months) of all customers 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_537_125537786_qa_2/task.toml b/tasks/0125_537_125537786_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cc2b9c93e489b00416f62ee38f8d75bb530df1c8 --- /dev/null +++ b/tasks/0125_537_125537786_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0125_537_125537786_qa_2" +description = "What is the average tenure (in months) of all customers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0125/537/125537786.ipynb_qa_2" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "32.37" +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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "32.37" +QUESTION = "What is the average tenure (in months) of all customers 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/0125_624_125624875_qa_1/instruction.md b/tasks/0125_624_125624875_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7313449682f926f1875549ef1bcbd6ccf8cc49a6 --- /dev/null +++ b/tasks/0125_624_125624875_qa_1/instruction.md @@ -0,0 +1,19 @@ +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): +- training.csv +- validation.csv +- evaluation.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which dataset has the highest number of 'O' tags, and what is the count? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, plain number). + +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_624_125624875_qa_1/task.toml b/tasks/0125_624_125624875_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cdedfb8399e6ca3a92e673f9d642b031b139bfb8 --- /dev/null +++ b/tasks/0125_624_125624875_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0125_624_125624875_qa_1" +description = "Which dataset has the highest number of 'O' tags, and what is the count?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0125/624/125624875.ipynb_qa_1" +kaggle_dataset_name = "abhinavwalia95/chemdner-iob-annotated-chemical-named-etities" +gold_answer = "training, 631474" +reward_mode_initial = "list" +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 = "abhinavwalia95__chemdner-iob-annotated-chemical-named-etities" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abhinavwalia95/chemdner-iob-annotated-chemical-named-etities" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "training, 631474" +QUESTION = "Which dataset has the highest number of 'O' tags, and what is the count?" +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/0128_624_128624067_qa_3/instruction.md b/tasks/0128_624_128624067_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..928fc02281ea98905e842021b631c2568b5f18af --- /dev/null +++ b/tasks/0128_624_128624067_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): +- ramen-ratings.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of all 5-star rated ramen products in the dataset are Japanese in origin? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a percentage (e.g. 18), not a fraction. + +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_624_128624067_qa_3/task.toml b/tasks/0128_624_128624067_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0565455abd2d6c978501edc4c55feba9b03e557a --- /dev/null +++ b/tasks/0128_624_128624067_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0128_624_128624067_qa_3" +description = "What percentage of all 5-star rated ramen products in the dataset are Japanese in origin?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0128/624/128624067.ipynb_qa_3" +kaggle_dataset_name = "residentmario/ramen-ratings" +gold_answer = "18" +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 = "residentmario__ramen-ratings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "residentmario/ramen-ratings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "18" +QUESTION = "What percentage of all 5-star rated ramen products in the dataset are Japanese in origin?" +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/0129_211_129211866_qa_3/instruction.md b/tasks/0129_211_129211866_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4ad1296dffdc10202f72ca1ffb352a21c49441b1 --- /dev/null +++ b/tasks/0129_211_129211866_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): +- auto-mpg.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the standard error of the mean estimate for miles per gallon (mpg) 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/0129_211_129211866_qa_3/task.toml b/tasks/0129_211_129211866_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e6ba9e015bac685cb22eb2addfa66b5a9da2e2b2 --- /dev/null +++ b/tasks/0129_211_129211866_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0129_211_129211866_qa_3" +description = "What is the standard error of the mean estimate for miles per gallon (mpg) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0129/211/129211866.ipynb_qa_3" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "0.3918" +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__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.3918" +QUESTION = "What is the standard error of the mean estimate for miles per gallon (mpg) 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/0129_395_129395519_qa_2/instruction.md b/tasks/0129_395_129395519_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..29e4f24057411b87919d81c53c3d7913aa754e6c --- /dev/null +++ b/tasks/0129_395_129395519_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): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +By how many standard deviations above the North American sales mean is the top-selling game in North America? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a plain number (e.g. 50.48), not a fraction or percentage. + +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/0129_395_129395519_qa_2/task.toml b/tasks/0129_395_129395519_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9c34e31bce7dae7b492b56d1e18b0d07f0c31a34 --- /dev/null +++ b/tasks/0129_395_129395519_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0129_395_129395519_qa_2" +description = "By how many standard deviations above the North American sales mean is the top-selling game in North America?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0129/395/129395519.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "50.48 standard deviations above the mean." +reward_mode_initial = "flexible" +package_tier = 3 +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 = "50.48 standard deviations above the mean." +QUESTION = "By how many standard deviations above the North American sales mean is the top-selling game in North America?" +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/0129_786_129786687_qa_5/instruction.md b/tasks/0129_786_129786687_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b4901c1d206fdc3f1f841d9ec851e4b3ce2d08f9 --- /dev/null +++ b/tasks/0129_786_129786687_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent clarity category 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/0129_786_129786687_qa_5/task.toml b/tasks/0129_786_129786687_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..819dde7a9fd80b13d57ca6c4b3bf810e404ef93b --- /dev/null +++ b/tasks/0129_786_129786687_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0129_786_129786687_qa_5" +description = "What is the most frequent clarity category in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0129/786/129786687.ipynb_qa_5" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "SI1" +reward_mode_initial = "exact_short" +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "SI1" +QUESTION = "What is the most frequent clarity category 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/0130_213_130213131_qa_3/instruction.md b/tasks/0130_213_130213131_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..79f2ad1a71ce4ec2ca51e5787ccab60577353709 --- /dev/null +++ b/tasks/0130_213_130213131_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After applying the Box-Cox transformation to normalize the target variable, what is the estimated optimal lambda value? + +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/0130_213_130213131_qa_3/task.toml b/tasks/0130_213_130213131_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6c9832f63f88a78f9178f7945a4b760b30e1fec7 --- /dev/null +++ b/tasks/0130_213_130213131_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0130_213_130213131_qa_3" +description = "After applying the Box-Cox transformation to normalize the target variable, what is the estimated optimal lambda value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0130/213/130213131.ipynb_qa_3" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "0.0435" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.0435" +QUESTION = "After applying the Box-Cox transformation to normalize the target variable, what is the estimated optimal lambda value?" +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/0130_740_130740848_qa_1/instruction.md b/tasks/0130_740_130740848_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a0503cb0c796fadb564c91d3f6127a439f72174d --- /dev/null +++ b/tasks/0130_740_130740848_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_u6lujuX_CVtuZ9i (1).csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After preprocessing, what is the most common value in the 'Dependents' column? + +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/0130_740_130740848_qa_1/task.toml b/tasks/0130_740_130740848_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a43d9c979b7118e30991541d0aa77c8942fe830a --- /dev/null +++ b/tasks/0130_740_130740848_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0130_740_130740848_qa_1" +description = "After preprocessing, what is the most common value in the 'Dependents' column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0130/740/130740848.ipynb_qa_1" +kaggle_dataset_name = "ninzaami/loan-predication" +gold_answer = "0" +reward_mode_initial = "numeric" +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 = "ninzaami__loan-predication" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ninzaami/loan-predication" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "After preprocessing, what is the most common value in the 'Dependents' column?" +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/0130_870_130870201_qa_1/instruction.md b/tasks/0130_870_130870201_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2065388eccec09fe80064ed4ae5ab649bf346e25 --- /dev/null +++ b/tasks/0130_870_130870201_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): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many Pokémon entries were identified as Mega Evolutions before the data 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/0130_870_130870201_qa_1/task.toml b/tasks/0130_870_130870201_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7f946c4759c4bdbc8926af00d3d8d5d33460bfed --- /dev/null +++ b/tasks/0130_870_130870201_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0130_870_130870201_qa_1" +description = "How many Pokémon entries were identified as Mega Evolutions before the data cleaning process?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0130/870/130870201.ipynb_qa_1" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "49" +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 = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "49" +QUESTION = "How many Pokémon entries were identified as Mega Evolutions before the data 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/0130_890_130890369_qa_2/instruction.md b/tasks/0130_890_130890369_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..276b5caae21f4671dc18a04525af2955d88a4003 --- /dev/null +++ b/tasks/0130_890_130890369_qa_2/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): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequently occurring value in the Product_Category_2 column after imputation of 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/0130_890_130890369_qa_2/task.toml b/tasks/0130_890_130890369_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b4013251660175f98ef9f07270568012d1d9130c --- /dev/null +++ b/tasks/0130_890_130890369_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0130_890_130890369_qa_2" +description = "What is the most frequently occurring value in the Product_Category_2 column after imputation of missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0130/890/130890369.ipynb_qa_2" +kaggle_dataset_name = "sdolezel/black-friday" +gold_answer = "8.0" +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 = "sdolezel__black-friday" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sdolezel/black-friday" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "8.0" +QUESTION = "What is the most frequently occurring value in the Product_Category_2 column after imputation of missing values?" +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/0131_249_131249802_qa_5/instruction.md b/tasks/0131_249_131249802_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..eed9bdfc354602dafe33dd7689ca2971bce12b83 --- /dev/null +++ b/tasks/0131_249_131249802_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): +- kag_risk_factors_cervical_cancer.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest missing value count observed in any feature before imputation 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_249_131249802_qa_5/task.toml b/tasks/0131_249_131249802_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e63e9b99d6dfb2adc90ff52ed3a82e395a44633f --- /dev/null +++ b/tasks/0131_249_131249802_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0131_249_131249802_qa_5" +description = "What is the highest missing value count observed in any feature before imputation in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0131/249/131249802.ipynb_qa_5" +kaggle_dataset_name = "loveall/cervical-cancer-risk-classification" +gold_answer = "787" +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 = "loveall__cervical-cancer-risk-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "loveall/cervical-cancer-risk-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "787" +QUESTION = "What is the highest missing value count observed in any feature before imputation 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/0131_609_131609730_qa_1/instruction.md b/tasks/0131_609_131609730_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..66230fbbceafbf88066aeed3c1f97bb57a0f971e --- /dev/null +++ b/tasks/0131_609_131609730_qa_1/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): +- german_credit_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the proportion of male and female borrowers in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as comma-separated