diff --git a/tasks/0000_429_429367_qa_3/instruction.md b/tasks/0000_429_429367_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9294102c98543c201665ba872178c0183bf7a979 --- /dev/null +++ b/tasks/0000_429_429367_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): +- starcraft.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Does the minimum APM increase as the league number increases? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_429_429367_qa_3/task.toml b/tasks/0000_429_429367_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..24eda484daf97d29a800ce06a57cdb64585c27a1 --- /dev/null +++ b/tasks/0000_429_429367_qa_3/task.toml @@ -0,0 +1,56 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_429_429367_qa_3" +description = "Does the minimum APM increase as the league number increases?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/429/429367.ipynb_qa_3" +kaggle_dataset_name = "sfu-summit/starcraft-ii-replay-analysis" +gold_answer = "Yes" +reward_mode_initial = "exact_bool" +package_tier = 0 +difficulty_level = 2 +[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 = "sfu-summit__starcraft-ii-replay-analysis" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sfu-summit/starcraft-ii-replay-analysis" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Yes" +QUESTION = "Does the minimum APM increase as the league number increases?" +REWARD_MODE = "exact_bool" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0000_838_838183_qa_2/instruction.md b/tasks/0000_838_838183_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e5ddbdf5b4ceb50862215d16cb296306e72de71b --- /dev/null +++ b/tasks/0000_838_838183_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: +How many messages in the dataset are classified as 'spam'? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_838_838183_qa_2/task.toml b/tasks/0000_838_838183_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1c47d3932a1b026ade9c2d94418dca8b49b5469c --- /dev/null +++ b/tasks/0000_838_838183_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_838_838183_qa_2" +description = "How many messages in the dataset are classified as 'spam'?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/838/838183.ipynb_qa_2" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "747" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "747" +QUESTION = "How many messages in the dataset are classified as 'spam'?" +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/0000_988_988342_qa_4/instruction.md b/tasks/0000_988_988342_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2d5c08b3214f7d4844a9bbafba052139cadc5808 --- /dev/null +++ b/tasks/0000_988_988342_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): +- sources.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common cause of tsunamis in the dataset when excluding 'Unknown' and 'Questionable Earthquake' classifications? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_988_988342_qa_4/task.toml b/tasks/0000_988_988342_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..78cd3c3aa101253f4fb8d7fca0bb0a22e6530a32 --- /dev/null +++ b/tasks/0000_988_988342_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_988_988342_qa_4" +description = "What is the most common cause of tsunamis in the dataset when excluding 'Unknown' and 'Questionable Earthquake' classifications?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/988/988342.ipynb_qa_4" +kaggle_dataset_name = "noaa/seismic-waves" +gold_answer = "Earthquake" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "noaa__seismic-waves" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "noaa/seismic-waves" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Earthquake" +QUESTION = "What is the most common cause of tsunamis in the dataset when excluding 'Unknown' and 'Questionable Earthquake' classifications?" +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_379_1379568_qa_4/instruction.md b/tasks/0001_379_1379568_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cb4ed42248719efd95038a2213c3226f2c6c00e8 --- /dev/null +++ b/tasks/0001_379_1379568_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): +- rainfall in india 1901-2015.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average annual rainfall for the subdivision with the lowest average annual rainfall 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_379_1379568_qa_4/task.toml b/tasks/0001_379_1379568_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..33e277fd7b495df570c9ce6d8dcc0a672704dca4 --- /dev/null +++ b/tasks/0001_379_1379568_qa_4/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_379_1379568_qa_4" +description = "What is the average annual rainfall for the subdivision with the lowest average annual rainfall in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/379/1379568.ipynb_qa_4" +kaggle_dataset_name = "rajanand/rainfall-in-india" +gold_answer = "292.673043" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 + +[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 = "rajanand__rainfall-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/rainfall-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "292.673043" +QUESTION = "What is the average annual rainfall for the subdivision with the lowest average annual rainfall in the dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0001_452_1452536_qa_1/instruction.md b/tasks/0001_452_1452536_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c387becd0dc5a3455a09d8cc48931f89d7db5d6e --- /dev/null +++ b/tasks/0001_452_1452536_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): +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which team had the lowest True Performance in the dataset, and what was their True Performance 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/0001_452_1452536_qa_1/task.toml b/tasks/0001_452_1452536_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1593c7231465ffadbe03b5c68d841b0a1e9bb9b7 --- /dev/null +++ b/tasks/0001_452_1452536_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_452_1452536_qa_1" +description = "Which team had the lowest True Performance in the dataset, and what was their True Performance value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/452/1452536.ipynb_qa_1" +kaggle_dataset_name = "hugomathien/soccer" +gold_answer = "Borussia Dortmund in the 2014/2015 season with -24.03 points." +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "St. Mirren, with a True Performance value of -38.33" +QUESTION = "Which team had the lowest True Performance in the dataset, and what was their True Performance 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_487_1487950_qa_1/instruction.md b/tasks/0001_487_1487950_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..070afdc57d95d1c463d6cd04b3030a1c6f2f1a56 --- /dev/null +++ b/tasks/0001_487_1487950_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): +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of correct bets when betting on the safest outcome (lowest odds) for 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_1/task.toml b/tasks/0001_487_1487950_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b444c5730bee929bbd420ed1d9e51527f91d0698 --- /dev/null +++ b/tasks/0001_487_1487950_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_487_1487950_qa_1" +description = "What is the percentage of correct bets when betting on the safest outcome (lowest odds) for 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_1" +kaggle_dataset_name = "hugomathien/soccer" +gold_answer = "45.86%" +reward_mode_initial = "flexible" +package_tier = 3 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "53.25%" +QUESTION = "What is the percentage of correct bets when betting on the safest outcome (lowest odds) for every match 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/0001_520_1520172_qa_4/instruction.md b/tasks/0001_520_1520172_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1dfecaac02a091b1af1cd40f609f0d63d2ceb7fa --- /dev/null +++ b/tasks/0001_520_1520172_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): +- 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 total number of unique appointment 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_520_1520172_qa_4/task.toml b/tasks/0001_520_1520172_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3ef36e25ebfd0e445e56eb53de4c1e0219ee387f --- /dev/null +++ b/tasks/0001_520_1520172_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_520_1520172_qa_4" +description = "What is the total number of unique appointment dates in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/520/1520172.ipynb_qa_4" +kaggle_dataset_name = "joniarroba/noshowappointments" +gold_answer = "27" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "27" +QUESTION = "What is the total number of unique appointment dates 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_533_1533644_qa_3/instruction.md b/tasks/0001_533_1533644_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fb402917e35d191a9453dd4bb924e17cbec19b23 --- /dev/null +++ b/tasks/0001_533_1533644_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 feature (excluding the target variable) has the highest importance score in the Random Forest 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/0001_533_1533644_qa_3/task.toml b/tasks/0001_533_1533644_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a0ba3287a6b9f3724379d938e894764ad67abb90 --- /dev/null +++ b/tasks/0001_533_1533644_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_533_1533644_qa_3" +description = "Which feature (excluding the target variable) has the highest importance score in the Random Forest model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/533/1533644.ipynb_qa_3" +kaggle_dataset_name = "uciml/indian-liver-patient-records" +gold_answer = "Alkaline_Phosphotase" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "Alkaline_Phosphotase" +QUESTION = "Which feature (excluding the target variable) has the highest importance score in the Random Forest 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/0001_662_1662961_qa_5/instruction.md b/tasks/0001_662_1662961_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8d1a08bff00440c7cff867d7f5b59376edf71dde --- /dev/null +++ b/tasks/0001_662_1662961_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 median sugar content in cold 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/0001_662_1662961_qa_5/task.toml b/tasks/0001_662_1662961_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7ef0495b2a9703311f6fdddf4ecdcc9298375c9e --- /dev/null +++ b/tasks/0001_662_1662961_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_662_1662961_qa_5" +description = "What is the median sugar content in cold cereals?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/662/1662961.ipynb_qa_5" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "7.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7.0" +QUESTION = "What is the median sugar content in cold cereals?" +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_683_1683832_qa_5/instruction.md b/tasks/0001_683_1683832_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..37bfd0d658a6ed2e19fefe8891bbb9d2053c62eb --- /dev/null +++ b/tasks/0001_683_1683832_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): +- poe_stats.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which division has the lowest average number of completed challenges 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/0001_683_1683832_qa_5/task.toml b/tasks/0001_683_1683832_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..19b7a7d6269394bd89adf92583b5fc0f5a4b622e --- /dev/null +++ b/tasks/0001_683_1683832_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_683_1683832_qa_5" +description = "Which division has the lowest average number of completed challenges according to the dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/683/1683832.ipynb_qa_5" +kaggle_dataset_name = "gagazet/path-of-exile-league-statistic" +gold_answer = "SSF Harbinger HC" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gagazet__path-of-exile-league-statistic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gagazet/path-of-exile-league-statistic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "SSF Harbinger HC" +QUESTION = "Which division has the lowest average number of completed challenges 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/0001_689_1689474_qa_2/instruction.md b/tasks/0001_689_1689474_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2d67f5e7acb7d3cea202e9086ce776715af14387 --- /dev/null +++ b/tasks/0001_689_1689474_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): +- data.csv +- documentation.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct time series in the dataset are explicitly related to wheat production in Germany? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_689_1689474_qa_2/task.toml b/tasks/0001_689_1689474_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a298f524e9a0f537b4f7ece0f2e237a68b4643b5 --- /dev/null +++ b/tasks/0001_689_1689474_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_689_1689474_qa_2" +description = "How many distinct time series in the dataset are explicitly related to wheat production in Germany?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/689/1689474.ipynb_qa_2" +kaggle_dataset_name = "sohier/nber-macrohistory-database" +gold_answer = "4" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "sohier__nber-macrohistory-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sohier/nber-macrohistory-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "How many distinct time series in the dataset are explicitly related to wheat production in Germany?" +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_692_1692435_qa_3/instruction.md b/tasks/0001_692_1692435_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6b3b9ea7ff8b35c22d9cc9f0fe58577f4deb1f75 --- /dev/null +++ b/tasks/0001_692_1692435_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 species has the smallest average 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/0001_692_1692435_qa_3/task.toml b/tasks/0001_692_1692435_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..97df424572fd76573fc3a3e78d8a2618e6863ca7 --- /dev/null +++ b/tasks/0001_692_1692435_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_692_1692435_qa_3" +description = "Which species has the smallest average sepal width 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_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-versicolor" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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" +QUESTION = "Which species has the smallest average sepal width 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_350_2350400_qa_3/instruction.md b/tasks/0002_350_2350400_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..77a3694418ac70a015e2ffc67ae900cadf3a2882 --- /dev/null +++ b/tasks/0002_350_2350400_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 most common configuration of bedrooms and bathrooms in the dataset, 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/0002_350_2350400_qa_3/task.toml b/tasks/0002_350_2350400_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2ed40ff60fe6efeb50fb80cea50f9b234f242793 --- /dev/null +++ b/tasks/0002_350_2350400_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0002_350_2350400_qa_3" +description = "What is the most common configuration of bedrooms and bathrooms in the dataset, based on the distribution analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/350/2350400.ipynb_qa_3" +kaggle_dataset_name = "anthonypino/melbourne-housing-market" +gold_answer = "3 bedrooms, 1 bathroom" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "anthonypino__melbourne-housing-market" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "anthonypino/melbourne-housing-market" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3 bedrooms, 1 bathroom" +QUESTION = "What is the most common configuration of bedrooms and bathrooms in the dataset, based on the distribution 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/0010_397_10397139_qa_4/instruction.md b/tasks/0010_397_10397139_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d7ceaab194110c519086bf7ddc00a4068585ff8f --- /dev/null +++ b/tasks/0010_397_10397139_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 most preferred genre among the top-rated animes for a randomly selected user? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_397_10397139_qa_4/task.toml b/tasks/0010_397_10397139_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5e4f02648640d0abd7c8a0d48ab898452de47263 --- /dev/null +++ b/tasks/0010_397_10397139_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0010_397_10397139_qa_4" +description = "What is the most preferred genre among the top-rated animes for a randomly selected user?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0010/397/10397139.ipynb_qa_4" +kaggle_dataset_name = "CooperUnion/anime-recommendations-database" +gold_answer = "Romance" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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__anime-recommendations-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "CooperUnion/anime-recommendations-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Romance" +QUESTION = "What is the most preferred genre among the top-rated animes for a randomly selected user?" +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_695_13695761_qa_1/instruction.md b/tasks/0013_695_13695761_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4ba079518b1c77d472daf4bcffe773946dd7a9b2 --- /dev/null +++ b/tasks/0013_695_13695761_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): +- cwurData.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest coefficient in the final regression model predicting world rank? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_695_13695761_qa_1/task.toml b/tasks/0013_695_13695761_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..deccc3ca40c271990ebf33fb48c3197d2ed51d89 --- /dev/null +++ b/tasks/0013_695_13695761_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0013_695_13695761_qa_1" +description = "Which feature has the highest coefficient in the final regression model predicting world rank?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/695/13695761.ipynb_qa_1" +kaggle_dataset_name = "mylesoneill/world-university-rankings" +gold_answer = "broad_impact" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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__world-university-rankings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mylesoneill/world-university-rankings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "broad_impact" +QUESTION = "Which feature has the highest coefficient in the final regression model predicting world rank? (Use only the ranking sub-indicator features: quality_of_education, alumni_employment, quality_of_faculty, publications, influence, citations, broad_impact, patents. Drop rows with missing values before fitting the 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/0021_562_21562813_qa_3/instruction.md b/tasks/0021_562_21562813_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..59b81843af63fd68baafd11dfb0419b963cbebcf --- /dev/null +++ b/tasks/0021_562_21562813_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 are the unique numerical values assigned to the species categories 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/0021_562_21562813_qa_3/task.toml b/tasks/0021_562_21562813_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7536b5612d5da9679f37527c511c6a26ac72cabe --- /dev/null +++ b/tasks/0021_562_21562813_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0021_562_21562813_qa_3" +description = "What are the unique numerical values assigned to the species categories after label encoding?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/562/21562813.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "[0, 1, 2]" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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, 2]" +QUESTION = "What are the unique numerical values assigned to the species categories after label encoding?" +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/0021_681_21681967_qa_1/instruction.md b/tasks/0021_681_21681967_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0f9eb358166a4226d8aee5bcea12e86da5647a61 --- /dev/null +++ b/tasks/0021_681_21681967_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 percentage of 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/0021_681_21681967_qa_1/task.toml b/tasks/0021_681_21681967_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..48ef7f120ab3702e4426c18f001ba316e91cae6f --- /dev/null +++ b/tasks/0021_681_21681967_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0021_681_21681967_qa_1" +description = "What is the percentage of spam messages in the SMS dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/681/21681967.ipynb_qa_1" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "13.41" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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.41" +QUESTION = "What is the percentage of 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/0022_272_22272220_qa_3/instruction.md b/tasks/0022_272_22272220_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fd6705cd36dc6b4a0949971250b2866eb6a20baa --- /dev/null +++ b/tasks/0022_272_22272220_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): +- 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 among the top 10 Pokémon with the highest total stats? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_272_22272220_qa_3/task.toml b/tasks/0022_272_22272220_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7c5ec081088431d6fe0345fc369d8802882536c8 --- /dev/null +++ b/tasks/0022_272_22272220_qa_3/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0022_272_22272220_qa_3" +description = "What is the most common primary type among the top 10 Pokémon with the highest total stats?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0022/272/22272220.ipynb_qa_3" +kaggle_dataset_name = "jolhe006/twitsdsplatzi" +gold_answer = "Dragon" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 + +[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 = "jolhe006__twitsdsplatzi" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "jolhe006/twitsdsplatzi" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Dragon" +QUESTION = "What is the most common primary type among the top 10 Pokémon with the highest total stats?" +REWARD_MODE = "exact_short" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0024_025_24025935_qa_4/instruction.md b/tasks/0024_025_24025935_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..af8350bbbcf154b86cb308e049e6cd8c1d8a457f --- /dev/null +++ b/tasks/0024_025_24025935_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): +- Accidental_Drug_Related_Deaths__2012-June_2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many cases in the dataset have missing data for the residence state? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_025_24025935_qa_4/task.toml b/tasks/0024_025_24025935_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6dbf294d09b7d240490f4fe0769d27107708955b --- /dev/null +++ b/tasks/0024_025_24025935_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0024_025_24025935_qa_4" +description = "How many cases in the dataset have missing data for the residence state?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/025/24025935.ipynb_qa_4" +kaggle_dataset_name = "addynaik/ct-accidental-drug-related-deaths-2012june-2017" +gold_answer = "1920" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "addynaik__ct-accidental-drug-related-deaths-2012june-2017" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "addynaik/ct-accidental-drug-related-deaths-2012june-2017" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1920" +QUESTION = "How many cases in the dataset have missing data for the residence state?" +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_071_32071401_qa_3/instruction.md b/tasks/0032_071_32071401_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4e915e55c00cd4c5eb62d5a4df0b7a5904ad1d39 --- /dev/null +++ b/tasks/0032_071_32071401_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 species has the highest median sepal width as indicated by the violin plot? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_3/task.toml b/tasks/0032_071_32071401_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bfb9dc6cbeb00033b11b8b41f12361956f1add04 --- /dev/null +++ b/tasks/0032_071_32071401_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0032_071_32071401_qa_3" +description = "Which species has the highest median sepal width as indicated by the violin plot?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/071/32071401.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-setosa" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 species has the highest median sepal width as indicated by the violin plot?" +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_205_32205594_qa_1/instruction.md b/tasks/0032_205_32205594_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d3ae50200835f6614aeae931eb91e644b1b64c25 --- /dev/null +++ b/tasks/0032_205_32205594_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 text message 20170820 - Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average difference in message length between spam and ham 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/0032_205_32205594_qa_1/task.toml b/tasks/0032_205_32205594_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bdb571eee920f7f899051af5b124e4b349867a17 --- /dev/null +++ b/tasks/0032_205_32205594_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0032_205_32205594_qa_1" +description = "What is the average difference in message length between spam and ham messages in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/205/32205594.ipynb_qa_1" +kaggle_dataset_name = "team-ai/spam-text-message-classification" +gold_answer = "66.54 characters" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "66.54 characters" +QUESTION = "What is the average difference in message length between spam and ham messages 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/0032_431_32431999_qa_2/instruction.md b/tasks/0032_431_32431999_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..65d6cd14c89f4808a1f46e3e4c3bc994b29839d2 --- /dev/null +++ b/tasks/0032_431_32431999_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): +- norway_new_car_sales_by_month.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the highest monthly car sales quantity recorded in the dataset, and in which year and month did it occur? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_431_32431999_qa_2/task.toml b/tasks/0032_431_32431999_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b134c78bd565c27343b8b68be3af5665deb7802b --- /dev/null +++ b/tasks/0032_431_32431999_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0032_431_32431999_qa_2" +description = "What was the highest monthly car sales quantity recorded in the dataset, and in which year and month did it occur?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/431/32431999.ipynb_qa_2" +kaggle_dataset_name = "dmi3kno/newcarsalesnorway" +gold_answer = "June 2015" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "dmi3kno__newcarsalesnorway" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dmi3kno/newcarsalesnorway" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "June 2015" +QUESTION = "What was the highest monthly car sales quantity recorded in the dataset, and in which year and month did it occur?" +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_308_33308132_qa_3/instruction.md b/tasks/0033_308_33308132_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7f489d9ffd304df76b2a580ed4f0153ea8fb4005 --- /dev/null +++ b/tasks/0033_308_33308132_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 correlation coefficient between monthly income and employee attrition as shown in the distribution plot? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_308_33308132_qa_3/task.toml b/tasks/0033_308_33308132_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3f90ef696c0dcd6f93f5b417aa79576dec685056 --- /dev/null +++ b/tasks/0033_308_33308132_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0033_308_33308132_qa_3" +description = "What is the correlation coefficient between monthly income and employee attrition as shown in the distribution plot?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/308/33308132.ipynb_qa_3" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "-0.13" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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.13" +QUESTION = "What is the correlation coefficient between monthly income and employee attrition as shown in the distribution plot?" +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_023_34023168_qa_2/instruction.md b/tasks/0034_023_34023168_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8fbdd37aea0773118a80ffb3f9ff2de4de8cf5cf --- /dev/null +++ b/tasks/0034_023_34023168_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): +- winemag-data-130k-v2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest price of a wine in the dataset, and which specific wine has this price? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_023_34023168_qa_2/task.toml b/tasks/0034_023_34023168_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..33625869ec877439129bba5373e427531210891c --- /dev/null +++ b/tasks/0034_023_34023168_qa_2/task.toml @@ -0,0 +1,59 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0034_023_34023168_qa_2" +description = "What is the highest price of a wine in the dataset, and which specific wine has this price?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/023/34023168.ipynb_qa_2" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "3300.0, Château les Ormes Sorbet 2013 Médoc" +reward_mode_initial = "flexible" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "3300.0, Château les Ormes Sorbet 2013 Médoc" +QUESTION = "What is the highest price of a wine in the dataset, and which specific wine has this price?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0034_773_34773515_qa_5/instruction.md b/tasks/0034_773_34773515_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..38c5ea7504a717219e487a031b2863581d484954 --- /dev/null +++ b/tasks/0034_773_34773515_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 wines in the dataset are priced above the 75th percentile price ($42)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_5/task.toml b/tasks/0034_773_34773515_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a702349e57e4ad0d2ffb83f676cd06169cc3d178 --- /dev/null +++ b/tasks/0034_773_34773515_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0034_773_34773515_qa_5" +description = "What percentage of wines in the dataset are priced above the 75th percentile price ($42)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/773/34773515.ipynb_qa_5" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "22" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "22" +QUESTION = "What percentage of wines in the dataset are priced above the 75th percentile price ($42)?" +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/0035_188_35188217_qa_4/instruction.md b/tasks/0035_188_35188217_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1f4acf68320540da09cdcc8473afd6941a21d00d --- /dev/null +++ b/tasks/0035_188_35188217_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): +- SolarPrediction.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many hourly data points were included in the analysis after aggregating the dataset by month, day, and hour? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_188_35188217_qa_4/task.toml b/tasks/0035_188_35188217_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7505e44deb501cfb7d82a327100bad5ae2d846b6 --- /dev/null +++ b/tasks/0035_188_35188217_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0035_188_35188217_qa_4" +description = "How many hourly data points were included in the analysis after aggregating the dataset by month, day, and hour?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/188/35188217.ipynb_qa_4" +kaggle_dataset_name = "dronio/SolarEnergy" +gold_answer = "2,777" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "dronio__SolarEnergy" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dronio/SolarEnergy" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2,777" +QUESTION = "How many hourly data points were included in the analysis after aggregating the dataset by month, day, and hour?" +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_901_35901074_qa_5/instruction.md b/tasks/0035_901_35901074_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e4dcbfe77ee50c8e11b275eaed1494180ec428d3 --- /dev/null +++ b/tasks/0035_901_35901074_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 R² score of the AdaBoost Regressor model on 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/0035_901_35901074_qa_5/task.toml b/tasks/0035_901_35901074_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e70688ad957efaafb17bbb42d9dbde48b1056b65 --- /dev/null +++ b/tasks/0035_901_35901074_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0035_901_35901074_qa_5" +description = "What is the R² score of the AdaBoost Regressor model on the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/901/35901074.ipynb_qa_5" +kaggle_dataset_name = "new-york-city/nyc-property-sales" +gold_answer = "0.6863749384485794" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "new-york-city__nyc-property-sales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "new-york-city/nyc-property-sales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.6863749384485794" +QUESTION = "What is the R² score of the AdaBoost Regressor model on the training 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/0035_980_35980933_qa_5/instruction.md b/tasks/0035_980_35980933_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fa73948c6d5d84f9e1d2532cbcaba02bf9a05e8d --- /dev/null +++ b/tasks/0035_980_35980933_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: +Which feature has the lowest 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/0035_980_35980933_qa_5/task.toml b/tasks/0035_980_35980933_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..48bf1ec9b0ee548aeb9c3dd782c3ee4f914f93ab --- /dev/null +++ b/tasks/0035_980_35980933_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0035_980_35980933_qa_5" +description = "Which feature has the lowest mean value in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/980/35980933.ipynb_qa_5" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "smoothness_worst" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "fractal_dimension_se" +QUESTION = "Which feature has the lowest mean 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/0036_186_36186441_qa_2/instruction.md b/tasks/0036_186_36186441_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d077fdd576580ac6e84de59c3b5dd24c8e8eb8da --- /dev/null +++ b/tasks/0036_186_36186441_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 threshold value used to classify Pokémon as having a "powerful" Attack stat? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_186_36186441_qa_2/task.toml b/tasks/0036_186_36186441_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1750fca68413061211cf9b0e5129ecf86c0c2f71 --- /dev/null +++ b/tasks/0036_186_36186441_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0036_186_36186441_qa_2" +description = "What is the threshold value used to classify Pokémon as having a \"powerful\" Attack stat?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/186/36186441.ipynb_qa_2" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "79.00125" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "79.00125" +QUESTION = "What is the threshold value used to classify Pokémon as having a \"powerful\" Attack stat?" +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/0036_637_36637598_qa_2/instruction.md b/tasks/0036_637_36637598_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0f9b577beefbede0566d3e32cac1f32a6aa6484e --- /dev/null +++ b/tasks/0036_637_36637598_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): +- 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: +What are the top three most frequently reviewed grape varieties 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/0037_725_37725403_qa_5/instruction.md b/tasks/0037_725_37725403_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d3428a4e6c179edc6438f5280e81dfed11453188 --- /dev/null +++ b/tasks/0037_725_37725403_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: +How many samples were retained in the dataset after removing rows with missing descriptions? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_725_37725403_qa_5/task.toml b/tasks/0037_725_37725403_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..10de7bd05d88fc0d157806cc332a7daea7d29db3 --- /dev/null +++ b/tasks/0037_725_37725403_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0037_725_37725403_qa_5" +description = "How many samples were retained in the dataset after removing rows with missing descriptions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/725/37725403.ipynb_qa_5" +kaggle_dataset_name = "crowdflower/twitter-user-gender-classification" +gold_answer = "16306" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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-user-gender-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crowdflower/twitter-user-gender-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "16306" +QUESTION = "How many samples were retained in the dataset after removing rows with missing descriptions?" +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_672_38672361_qa_3/instruction.md b/tasks/0038_672_38672361_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ca3b2be69a804198350757836a5663fe4d1df0ad --- /dev/null +++ b/tasks/0038_672_38672361_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 median Age value used for 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/0038_672_38672361_qa_3/task.toml b/tasks/0038_672_38672361_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..022ac6c8890f6c612e3578a95c9bb5dbcb10c075 --- /dev/null +++ b/tasks/0038_672_38672361_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0038_672_38672361_qa_3" +description = "What is the median Age value used for imputation in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/672/38672361.ipynb_qa_3" +kaggle_dataset_name = "hesh97/titanicdataset-traincsv" +gold_answer = "28.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "28.0" +QUESTION = "What is the median Age value used for imputation 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/0040_748_40748661_qa_3/instruction.md b/tasks/0040_748_40748661_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..19c87337d9c16966db4a37cb12b4eddd942336f2 --- /dev/null +++ b/tasks/0040_748_40748661_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 interquartile range (IQR) of customer ages in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_748_40748661_qa_3/task.toml b/tasks/0040_748_40748661_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1c227052e264962c60adcd292d9c38db9d480743 --- /dev/null +++ b/tasks/0040_748_40748661_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0040_748_40748661_qa_3" +description = "What is the interquartile range (IQR) of customer ages in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/748/40748661.ipynb_qa_3" +kaggle_dataset_name = "shwetabh123/mall-customers" +gold_answer = "20.25" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "20.25" +QUESTION = "What is the interquartile range (IQR) of customer ages 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/0040_880_40880494_qa_3/instruction.md b/tasks/0040_880_40880494_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f45706e54ed403fc7f2adf9e9186f9f48c97ea7b --- /dev/null +++ b/tasks/0040_880_40880494_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): +- test.csv +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the mean of the x values in the training data higher than the mean of the y 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/0040_880_40880494_qa_3/task.toml b/tasks/0040_880_40880494_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..49998dcd47ae38614964e859aef6899d1d2e713a --- /dev/null +++ b/tasks/0040_880_40880494_qa_3/task.toml @@ -0,0 +1,56 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0040_880_40880494_qa_3" +description = "Is the mean of the x values in the training data higher than the mean of the y values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/880/40880494.ipynb_qa_3" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "Yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 1 +[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 = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Yes" +QUESTION = "Is the mean of the x values in the training data higher than the mean of the y values?" +REWARD_MODE = "exact_bool" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0041_703_41703265_qa_5/instruction.md b/tasks/0041_703_41703265_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fc2a64d191c2850ca740a3597142903242c21670 --- /dev/null +++ b/tasks/0041_703_41703265_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 model had the highest weighted average precision, and what was its 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/0041_703_41703265_qa_5/task.toml b/tasks/0041_703_41703265_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8a0db04b9d9a34efb576cfe69200d0c748a54157 --- /dev/null +++ b/tasks/0041_703_41703265_qa_5/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0041_703_41703265_qa_5" +description = "Which model had the highest weighted average precision, and what was its value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/703/41703265.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Logistic, SVM, Naive Bayes with 100%" +reward_mode_initial = "list_csv" +package_tier = 1 +difficulty_level = 4 + +[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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Logistic, SVM, Naive Bayes with 100%" +QUESTION = "Which model had the highest weighted average precision, and what was its value?" +REWARD_MODE = "list_csv" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0041_888_41888820_qa_1/instruction.md b/tasks/0041_888_41888820_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d4cf6abb80cabce5aa310c66efa08cd778c3c7dd --- /dev/null +++ b/tasks/0041_888_41888820_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 shows the highest positive correlation with 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/0041_888_41888820_qa_1/task.toml b/tasks/0041_888_41888820_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..79d28b3b2714eaa7687e1120051cd120816284dc --- /dev/null +++ b/tasks/0041_888_41888820_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0041_888_41888820_qa_1" +description = "Which feature shows the highest positive correlation with the diabetes outcome in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/888/41888820.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 positive correlation with the diabetes outcome 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/0042_170_42170738_qa_4/instruction.md b/tasks/0042_170_42170738_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f05aa8e715f56b3cf4168d5b5035aae750caf55b --- /dev/null +++ b/tasks/0042_170_42170738_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 are the three mushroom attributes that most reliably predict mushroom edibility based on the dataset's percentage 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_170_42170738_qa_4/task.toml b/tasks/0042_170_42170738_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b7cc00b091fd309d572c7bd933139e2a541cfde2 --- /dev/null +++ b/tasks/0042_170_42170738_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0042_170_42170738_qa_4" +description = "What are the three mushroom attributes that most reliably predict mushroom edibility based on the dataset's percentage analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/170/42170738.ipynb_qa_4" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "population, gill-attachment, stalk-root" +reward_mode_initial = "list_csv" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "odor, spore-print-color, gill-color" +QUESTION = "What are the three mushroom attributes that most reliably predict mushroom edibility based on the dataset's percentage analysis?" +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/0043_029_43029106_qa_1/instruction.md b/tasks/0043_029_43029106_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2c5ccc831f327f9bc2ac328c3d1699f133eb7239 --- /dev/null +++ b/tasks/0043_029_43029106_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): +- Social_Network_Ads.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the count of users who did not make a purchase versus those who did 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/0043_029_43029106_qa_1/task.toml b/tasks/0043_029_43029106_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7926b616b574cd193ee4f01da6ec4caaf52281b4 --- /dev/null +++ b/tasks/0043_029_43029106_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0043_029_43029106_qa_1" +description = "What is the count of users who did not make a purchase versus those who did in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/029/43029106.ipynb_qa_1" +kaggle_dataset_name = "rakeshrau/social-network-ads" +gold_answer = "0: 257, 1: 143" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rakeshrau__social-network-ads" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rakeshrau/social-network-ads" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0: 257, 1: 143" +QUESTION = "What is the count of users who did not make a purchase versus those who did 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/0043_338_43338909_qa_1/instruction.md b/tasks/0043_338_43338909_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..512e6af992abc3292d52f385ccea98e401c2f3a2 --- /dev/null +++ b/tasks/0043_338_43338909_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 maximum Lift value achieved in any decile of predicted probabilities according to the model's performance 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/0043_338_43338909_qa_1/task.toml b/tasks/0043_338_43338909_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b9969b18ff059d0f0984d1362c54fd8c8013b1bb --- /dev/null +++ b/tasks/0043_338_43338909_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0043_338_43338909_qa_1" +description = "What is the maximum Lift value achieved in any decile of predicted probabilities according to the model's performance analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/338/43338909.ipynb_qa_1" +kaggle_dataset_name = "kabure/german-credit-data-with-risk" +gold_answer = "2.09" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "2.09" +QUESTION = "What is the maximum Lift value achieved in any decile of predicted probabilities according to the model's performance 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/0045_409_45409591_qa_4/instruction.md b/tasks/0045_409_45409591_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f3bebb691beef1577646b1e1237cf44e58c0ec82 --- /dev/null +++ b/tasks/0045_409_45409591_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): +- winemag-data-130k-v2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Does the 'price' column contain outliers based on the boxplot visualization in the outlier detection section? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_4/task.toml b/tasks/0045_409_45409591_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e08c18402f7addb9f232a19570d26f7ee58f6c6e --- /dev/null +++ b/tasks/0045_409_45409591_qa_4/task.toml @@ -0,0 +1,56 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0045_409_45409591_qa_4" +description = "Does the 'price' column contain outliers based on the boxplot visualization in the outlier detection section?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/409/45409591.ipynb_qa_4" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "Yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 2 +[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 = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Yes" +QUESTION = "Does the 'price' column contain outliers based on the boxplot visualization in the outlier detection section?" +REWARD_MODE = "exact_bool" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0047_417_47417997_qa_1/instruction.md b/tasks/0047_417_47417997_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..52f53837936b62bfc1c75dd39be0d567578c1eb1 --- /dev/null +++ b/tasks/0047_417_47417997_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 by the CatBoostClassifier according to the feature importance ranking? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_1/task.toml b/tasks/0047_417_47417997_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bbdda03aae459de9ff25f8267177f0a5a98f110d --- /dev/null +++ b/tasks/0047_417_47417997_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0047_417_47417997_qa_1" +description = "Which feature was identified as the most important by the CatBoostClassifier according to the feature importance ranking?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0047/417/47417997.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 was identified as the most important by the CatBoostClassifier according to the feature importance ranking?" +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_049_48049467_qa_5/instruction.md b/tasks/0048_049_48049467_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c792761a943d0fc92c78e60e2ff55274e6ecbc83 --- /dev/null +++ b/tasks/0048_049_48049467_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 was the value used to impute missing values in the MINIMUM_PAYMENTS column before 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/0048_049_48049467_qa_5/task.toml b/tasks/0048_049_48049467_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1dde17e2167c61f5495e8b57512505315910428e --- /dev/null +++ b/tasks/0048_049_48049467_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0048_049_48049467_qa_5" +description = "What was the value used to impute missing values in the MINIMUM_PAYMENTS column before data preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0048/049/48049467.ipynb_qa_5" +kaggle_dataset_name = "arjunbhasin2013/ccdata" +gold_answer = "864.21" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "864.21" +QUESTION = "What was the value used to impute missing values in the MINIMUM_PAYMENTS column before 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/0048_996_48996091_qa_4/instruction.md b/tasks/0048_996_48996091_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..76dbb2289953415ff56ed82961f4e6c2c61fe2fb --- /dev/null +++ b/tasks/0048_996_48996091_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 was the total number of samples in the test set used for evaluating 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/0048_996_48996091_qa_4/task.toml b/tasks/0048_996_48996091_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..80c7f839fca58b073adbc98606a2d6e3306d8cb5 --- /dev/null +++ b/tasks/0048_996_48996091_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0048_996_48996091_qa_4" +description = "What was the total number of samples in the test set used for evaluating the model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0048/996/48996091.ipynb_qa_4" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "1625" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "1625" +QUESTION = "What was the total number of samples in the test set used for evaluating the 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/0049_015_49015069_qa_1/instruction.md b/tasks/0049_015_49015069_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c7298a72d5a9dc0050d30f826c36e6ddb2814906 --- /dev/null +++ b/tasks/0049_015_49015069_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): +- AER_credit_card_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest expenditure 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/0049_015_49015069_qa_1/task.toml b/tasks/0049_015_49015069_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..88fbbf8193779854b52cd89bccf6c17f95b2667c --- /dev/null +++ b/tasks/0049_015_49015069_qa_1/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0049_015_49015069_qa_1" +description = "What is the highest expenditure value recorded in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0049/015/49015069.ipynb_qa_1" +kaggle_dataset_name = "dansbecker/aer-credit-card-data" +gold_answer = "3099.505" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 + +[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 = "dansbecker__aer-credit-card-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dansbecker/aer-credit-card-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3099.505" +QUESTION = "What is the highest expenditure value recorded in the dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0053_105_53105677_qa_2/instruction.md b/tasks/0053_105_53105677_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..40b1b89296ed06e537b4bfb1060571ec15b76181 --- /dev/null +++ b/tasks/0053_105_53105677_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: +After applying the Boruta feature selection algorithm, how many features were confirmed as important for the prediction of the target 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/0053_105_53105677_qa_2/task.toml b/tasks/0053_105_53105677_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8182bae63fc11de96090d1cb1c1e6ad46911fb2d --- /dev/null +++ b/tasks/0053_105_53105677_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0053_105_53105677_qa_2" +description = "After applying the Boruta feature selection algorithm, how many features were confirmed as important for the prediction of the target variable?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0053/105/53105677.ipynb_qa_2" +kaggle_dataset_name = "uciml/glass" +gold_answer = "8" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "8" +QUESTION = "After applying the Boruta feature selection algorithm, how many features were confirmed as important for the prediction of the target variable?" +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_256_54256432_qa_2/task.toml b/tasks/0054_256_54256432_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f4b224b430994c669ee045e248b7a93ae7ff8048 --- /dev/null +++ b/tasks/0054_256_54256432_qa_2/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0054_256_54256432_qa_2" +description = "What is the highest accuracy achieved by the Naïve Bayes classifier using any combination of features (PRCP, TMAX, TMIN) for rain prediction?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0054/256/54256432.ipynb_qa_2" +kaggle_dataset_name = "rtatman/did-it-rain-in-seattle-19482017" +gold_answer = "1.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 + +[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 = "rtatman__did-it-rain-in-seattle-19482017" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rtatman/did-it-rain-in-seattle-19482017" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.0" +QUESTION = "What is the highest accuracy achieved by the Naïve Bayes classifier using any combination of features (PRCP, TMAX, TMIN) for rain prediction?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0054_296_54296946_qa_1/instruction.md b/tasks/0054_296_54296946_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ef73170faba30d019bf4dba5449e9a95b4471589 --- /dev/null +++ b/tasks/0054_296_54296946_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 feature in the dataset shows the highest correlation with the price_range variable based on 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/0054_296_54296946_qa_1/task.toml b/tasks/0054_296_54296946_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..43a7b0213f70c355328a5c07e49e964da5f5ff93 --- /dev/null +++ b/tasks/0054_296_54296946_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0054_296_54296946_qa_1" +description = "Which feature in the dataset shows the highest correlation with the price_range variable based on the correlation matrix analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0054/296/54296946.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "ram" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 in the dataset shows the highest correlation with the price_range variable based on 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/0054_514_54514604_qa_1/instruction.md b/tasks/0054_514_54514604_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0e9a8793b69a24c5e5f856e5c78bda09d4b90050 --- /dev/null +++ b/tasks/0054_514_54514604_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 highest recorded insurance charge 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/0054_514_54514604_qa_1/task.toml b/tasks/0054_514_54514604_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..315b53dec70fcc1b5f7d2f1e6fdc08a5b5edf54d --- /dev/null +++ b/tasks/0054_514_54514604_qa_1/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0054_514_54514604_qa_1" +description = "What is the highest recorded insurance charge in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0054/514/54514604.ipynb_qa_1" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "63770.43" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 + +[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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "63770.43" +QUESTION = "What is the highest recorded insurance charge in the dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0055_115_55115812_qa_1/instruction.md b/tasks/0055_115_55115812_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8a97ea05b4c21a5dc043772cc567caa648588504 --- /dev/null +++ b/tasks/0055_115_55115812_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: +How many duplicate entries were present in the original wine quality dataset before 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/0055_115_55115812_qa_1/task.toml b/tasks/0055_115_55115812_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..001748eb7a03ea527f7c4dd3bad3dc19affcfc75 --- /dev/null +++ b/tasks/0055_115_55115812_qa_1/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0055_115_55115812_qa_1" +description = "How many duplicate entries were present in the original wine quality dataset before removal?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0055/115/55115812.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "240" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 + +[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 = "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 entries were present in the original wine quality dataset before removal?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0056_266_56266405_qa_4/instruction.md b/tasks/0056_266_56266405_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7dfda751b1c86680d42001d3408798e47f2375e1 --- /dev/null +++ b/tasks/0056_266_56266405_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 capital gain for 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/0056_266_56266405_qa_4/task.toml b/tasks/0056_266_56266405_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..290fcc4bc8f1740ecdef5fa2a866d581ce870b6c --- /dev/null +++ b/tasks/0056_266_56266405_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0056_266_56266405_qa_4" +description = "What is the average capital gain for all individuals in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0056/266/56266405.ipynb_qa_4" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "1085.15" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "1085.15" +QUESTION = "What is the average capital gain for all individuals 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/0058_806_58806875_qa_3/task.toml b/tasks/0058_806_58806875_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..92bca62be2b47a531222e7bddeb7773691da73d5 --- /dev/null +++ b/tasks/0058_806_58806875_qa_3/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0058_806_58806875_qa_3" +description = "What is the highest correlation coefficient between any two features (excluding the 'id' column) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0058/806/58806875.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "0.997855" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 + +[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 = "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.997855" +QUESTION = "What is the highest correlation coefficient between any two features (excluding the 'id' column) in the dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0058_924_58924130_qa_1/instruction.md b/tasks/0058_924_58924130_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..83bfe833336f1297326c96cef43fc77572fd52b6 --- /dev/null +++ b/tasks/0058_924_58924130_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: +How many rows in the dataset contain missing values in the 'Unnamed: 32' column before 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/0058_924_58924130_qa_1/task.toml b/tasks/0058_924_58924130_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c71aeeff06dc70fa6a88759f1441b69dad75c5ec --- /dev/null +++ b/tasks/0058_924_58924130_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0058_924_58924130_qa_1" +description = "How many rows in the dataset contain missing values in the 'Unnamed: 32' column before preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0058/924/58924130.ipynb_qa_1" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "569" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "569" +QUESTION = "How many rows in the dataset contain missing values in the 'Unnamed: 32' column before 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/0059_575_59575558_qa_3/instruction.md b/tasks/0059_575_59575558_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4d02e8c35612f495b6a46b736ab71ee7afdd2d82 --- /dev/null +++ b/tasks/0059_575_59575558_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: +How many distinct categories are present in the Neighborhood variable before applying rare 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/0059_575_59575558_qa_3/task.toml b/tasks/0059_575_59575558_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..38b4f402291d4736839aebdfe01ac1305524964a --- /dev/null +++ b/tasks/0059_575_59575558_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0059_575_59575558_qa_3" +description = "How many distinct categories are present in the Neighborhood variable before applying rare label encoding?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0059/575/59575558.ipynb_qa_3" +kaggle_dataset_name = "lespin/house-prices-dataset" +gold_answer = "25" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "25" +QUESTION = "How many distinct categories are present in the Neighborhood variable before applying rare 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/0062_642_62642092_qa_5/instruction.md b/tasks/0062_642_62642092_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d551b955eaddcc2f733b62beee9426912b1e7f28 --- /dev/null +++ b/tasks/0062_642_62642092_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 proportion of the dataset allocated to the training set when using an 80/20 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/0062_642_62642092_qa_5/task.toml b/tasks/0062_642_62642092_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..31d763765c05f311cdd77622441982a998d9c662 --- /dev/null +++ b/tasks/0062_642_62642092_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0062_642_62642092_qa_5" +description = "What is the proportion of the dataset allocated to the training set when using an 80/20 train-test split?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0062/642/62642092.ipynb_qa_5" +kaggle_dataset_name = "hb20007/gender-classification" +gold_answer = "0.8" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "0.8" +QUESTION = "What is the proportion of the dataset allocated to the training set when using an 80/20 train-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/0063_184_63184274_qa_1/instruction.md b/tasks/0063_184_63184274_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ca64da1cfbd5299fae647c7ef681d2a6e4388df2 --- /dev/null +++ b/tasks/0063_184_63184274_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: +How many missing values were present in the 'SkinThickness' 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_184_63184274_qa_1/task.toml b/tasks/0063_184_63184274_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4e9ea4fc9e64d0180a154b127b494dbf6e9b4ec8 --- /dev/null +++ b/tasks/0063_184_63184274_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0063_184_63184274_qa_1" +description = "How many missing values were present in the 'SkinThickness' column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0063/184/63184274.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "227" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 missing values were present in the 'SkinThickness' 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/0064_661_64661976_qa_3/instruction.md b/tasks/0064_661_64661976_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2563886dfe77dc9bfd04dec749a243de8bd05df0 --- /dev/null +++ b/tasks/0064_661_64661976_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 variable has the highest absolute correlation with employee attrition (left) 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_661_64661976_qa_3/task.toml b/tasks/0064_661_64661976_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a05605282df036ff3dc08b0a2e47a7ec3e0554c7 --- /dev/null +++ b/tasks/0064_661_64661976_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0064_661_64661976_qa_3" +description = "Which variable has the highest absolute correlation with employee attrition (left) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/661/64661976.ipynb_qa_3" +kaggle_dataset_name = "giripujar/hr-analytics" +gold_answer = "satisfaction_level" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "satisfaction_level" +QUESTION = "Which variable has the highest absolute correlation with employee attrition (left) 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_166_65166426_qa_5/instruction.md b/tasks/0065_166_65166426_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..75fe625b52ceefe05bc70100b3dcda4a6dc24b65 --- /dev/null +++ b/tasks/0065_166_65166426_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 most common marital status category after merging similar categories 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/0065_166_65166426_qa_5/task.toml b/tasks/0065_166_65166426_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cc3bde3916ac108f7d2c7f27ba21203c02a295c7 --- /dev/null +++ b/tasks/0065_166_65166426_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0065_166_65166426_qa_5" +description = "What is the most common marital status category after merging similar categories in the cleaned dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/166/65166426.ipynb_qa_5" +kaggle_dataset_name = "wenruliu/adult-income-dataset" +gold_answer = "Married" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "Married" +QUESTION = "What is the most common marital status category after merging similar categories 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/0065_573_65573990_qa_5/instruction.md b/tasks/0065_573_65573990_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b23f2f39ddf0398c2e0fbaf79dbac0d65e10f1ce --- /dev/null +++ b/tasks/0065_573_65573990_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 highest overall accuracy achieved by any 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/0065_573_65573990_qa_5/task.toml b/tasks/0065_573_65573990_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..62b0286c91fff327f2a52ecac1ac80212f2b083b --- /dev/null +++ b/tasks/0065_573_65573990_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0065_573_65573990_qa_5" +description = "What is the highest overall accuracy achieved by any model on the test set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/573/65573990.ipynb_qa_5" +kaggle_dataset_name = "team-ai/spam-text-message-classification" +gold_answer = "98" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "98" +QUESTION = "What is the highest overall accuracy achieved by any model on the test set?" +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/0065_789_65789409_qa_2/instruction.md b/tasks/0065_789_65789409_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3f2c947347efe0587791fc0ec5c80f0883fb1e59 --- /dev/null +++ b/tasks/0065_789_65789409_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 top feature identified by XGBoost's feature importance analysis for predicting log_price? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_789_65789409_qa_2/task.toml b/tasks/0065_789_65789409_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6438fbe2660456b1a9a2ca67a9f71eb20f5df667 --- /dev/null +++ b/tasks/0065_789_65789409_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0065_789_65789409_qa_2" +description = "What is the top feature identified by XGBoost's feature importance analysis for predicting log_price?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0065/789/65789409.ipynb_qa_2" +kaggle_dataset_name = "stevezhenghp/airbnb-price-prediction" +gold_answer = "room_type" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "stevezhenghp__airbnb-price-prediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "stevezhenghp/airbnb-price-prediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "room_type" +QUESTION = "What is the top feature identified by XGBoost's feature importance analysis for predicting log_price?" +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_039_66039698_qa_2/instruction.md b/tasks/0066_039_66039698_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d862b327bdd29a7c8f9fa0cfdc91074406cc74f2 --- /dev/null +++ b/tasks/0066_039_66039698_qa_2/instruction.md @@ -0,0 +1,25 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- 2007.csv +- 2008.csv +- 2009.csv +- 2010.csv +- 2011.csv +- 2012.csv +- 2013.csv +- 2014.csv +- 2015.csv +- 2016.csv +- 2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +By how many percentage points did the popularity of Labrador Retrievers decrease from 2008 to 2009? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_039_66039698_qa_2/task.toml b/tasks/0066_039_66039698_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c7dfb856ff4314202045ee631416ea5f7d07c4d8 --- /dev/null +++ b/tasks/0066_039_66039698_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0066_039_66039698_qa_2" +description = "By how many percentage points did the popularity of Labrador Retrievers decrease from 2008 to 2009?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/039/66039698.ipynb_qa_2" +kaggle_dataset_name = "kingburrito666/largest-dog-breed-data-set" +gold_answer = "-0.509763" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kingburrito666__largest-dog-breed-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kingburrito666/largest-dog-breed-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.509763" +QUESTION = "By how many percentage points did the popularity of Labrador Retrievers decrease from 2008 to 2009?" +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_1/instruction.md b/tasks/0066_107_66107048_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4d9ace58bb46debf5fac5697129b42d9b7c64255 --- /dev/null +++ b/tasks/0066_107_66107048_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): +- archive.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequently recorded February average temperature in the Northeast, and how many times does it occur? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_1/task.toml b/tasks/0066_107_66107048_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f276edf43c0a9578a42edc6ab83c2cb8bfd2f07c --- /dev/null +++ b/tasks/0066_107_66107048_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0066_107_66107048_qa_1" +description = "What is the most frequently recorded February average temperature in the Northeast, and how many times does it occur?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/107/66107048.ipynb_qa_1" +kaggle_dataset_name = "groundhogclub/groundhog-day" +gold_answer = "26.2°F, 5 times" +reward_mode_initial = "flexible" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "26.2°F, 5 times" +QUESTION = "What is the most frequently recorded February average temperature in the Northeast, and how many times does it occur?" +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/0069_698_69698122_qa_4/instruction.md b/tasks/0069_698_69698122_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d995991c48ba9e5ab83370cbe1770ae4a9c75dac --- /dev/null +++ b/tasks/0069_698_69698122_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 instances remain in the dataset after removing rows with 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/0069_698_69698122_qa_4/task.toml b/tasks/0069_698_69698122_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..79410dc34cfaf07f7ebd4bb5a149630ce0394b16 --- /dev/null +++ b/tasks/0069_698_69698122_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0069_698_69698122_qa_4" +description = "How many instances remain in the dataset after removing rows with missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0069/698/69698122.ipynb_qa_4" +kaggle_dataset_name = "wenruliu/adult-income-dataset" +gold_answer = "45222" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "45222" +QUESTION = "How many instances remain in the dataset after removing rows with 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/0073_893_73893447_qa_1/instruction.md b/tasks/0073_893_73893447_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4bf1ad92c8707fe4e1dc32e1149db2a20659dde4 --- /dev/null +++ b/tasks/0073_893_73893447_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 percentage of customers who defaulted on their payment 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/0073_893_73893447_qa_1/task.toml b/tasks/0073_893_73893447_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..106d5646946fc35de24cf4f8e672a97f4ddcb686 --- /dev/null +++ b/tasks/0073_893_73893447_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0073_893_73893447_qa_1" +description = "What is the percentage of customers who defaulted on their payment in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0073/893/73893447.ipynb_qa_1" +kaggle_dataset_name = "uciml/default-of-credit-card-clients-dataset" +gold_answer = "22" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 is the percentage of customers who defaulted on their payment 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/0074_346_74346808_qa_4/instruction.md b/tasks/0074_346_74346808_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e6d9c6a1c817bf4d6274783fb933148dc3865329 --- /dev/null +++ b/tasks/0074_346_74346808_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): +- Life Expectancy 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 life expectancy 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/0074_346_74346808_qa_4/task.toml b/tasks/0074_346_74346808_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..92a581e3d3f16b9228297c5aa2a9f35c06b2930d --- /dev/null +++ b/tasks/0074_346_74346808_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0074_346_74346808_qa_4" +description = "What is the most frequently occurring life expectancy value in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/346/74346808.ipynb_qa_4" +kaggle_dataset_name = "kumarajarshi/life-expectancy-who" +gold_answer = "73.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "73.0" +QUESTION = "What is the most frequently occurring life expectancy 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/0074_600_74600268_qa_2/instruction.md b/tasks/0074_600_74600268_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..446ff292ff011d0f2cf349c5d331fc254cd99ba0 --- /dev/null +++ b/tasks/0074_600_74600268_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: +After flattening the images for machine learning processing, what was the resulting feature vector dimensionality for each image sample in 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/0074_600_74600268_qa_2/task.toml b/tasks/0074_600_74600268_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..08a9f78d34cec5653723c9754432456a6b5b7a49 --- /dev/null +++ b/tasks/0074_600_74600268_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0074_600_74600268_qa_2" +description = "After flattening the images for machine learning processing, what was the resulting feature vector dimensionality for each image sample in the training set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/600/74600268.ipynb_qa_2" +kaggle_dataset_name = "ardamavi/sign-language-digits-dataset" +gold_answer = "4096" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "4096" +QUESTION = "After flattening the images for machine learning processing, what was the resulting feature vector dimensionality for each image sample in 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/0075_282_75282744_qa_2/instruction.md b/tasks/0075_282_75282744_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..282d84923d91ce6fda487fccebd90f0583de5b20 --- /dev/null +++ b/tasks/0075_282_75282744_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 mean alcohol content for wines classified as good quality (1) in the transformed 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/0075_282_75282744_qa_2/task.toml b/tasks/0075_282_75282744_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c46e5fdc65914db189bac40fb40d257f238d1bc4 --- /dev/null +++ b/tasks/0075_282_75282744_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0075_282_75282744_qa_2" +description = "What is the mean alcohol content for wines classified as good quality (1) in the transformed dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/282/75282744.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "11.465913" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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.465913" +QUESTION = "What is the mean alcohol content for wines classified as good quality (1) in the transformed 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/0075_813_75813284_qa_5/instruction.md b/tasks/0075_813_75813284_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ed6f3ecb8c3601548baa467da039e5826ec91b1f --- /dev/null +++ b/tasks/0075_813_75813284_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): +- 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 percentage difference in no-show rates between genders 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/0075_813_75813284_qa_5/task.toml b/tasks/0075_813_75813284_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..68c726787c9ef0a0603d4e2d1da3b6451e2c8e25 --- /dev/null +++ b/tasks/0075_813_75813284_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0075_813_75813284_qa_5" +description = "What is the percentage difference in no-show rates between genders in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0075/813/75813284.ipynb_qa_5" +kaggle_dataset_name = "joniarroba/noshowappointments" +gold_answer = "0.8% higher no-show rate for females compared to males" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "0.35% higher no-show rate for females compared to males" +QUESTION = "What is the percentage difference in no-show rates between genders 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/0077_902_77902994_qa_1/instruction.md b/tasks/0077_902_77902994_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9e1b27fdc6e2d2b24b7edf64c5eb5a658042e850 --- /dev/null +++ b/tasks/0077_902_77902994_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the Pearson correlation coefficient between median income and median house 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/0077_902_77902994_qa_1/task.toml b/tasks/0077_902_77902994_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d806727174cf76887cc79353b8de3306a7bd1cf6 --- /dev/null +++ b/tasks/0077_902_77902994_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0077_902_77902994_qa_1" +description = "What is the Pearson correlation coefficient between median income and median house value in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0077/902/77902994.ipynb_qa_1" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "0.688075" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "0.688075" +QUESTION = "What is the Pearson correlation coefficient between median income and median house 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/0080_832_80832047_qa_5/instruction.md b/tasks/0080_832_80832047_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..eead758d0859f9a9d892a2fdcb6da116505b93b5 --- /dev/null +++ b/tasks/0080_832_80832047_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 difference between the maximum number of people recorded and the median number of people 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_832_80832047_qa_5/task.toml b/tasks/0080_832_80832047_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..07531c3caa2f976c8ef5b178f4042a25d5cfca18 --- /dev/null +++ b/tasks/0080_832_80832047_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0080_832_80832047_qa_5" +description = "What is the difference between the maximum number of people recorded and the median number of people in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0080/832/80832047.ipynb_qa_5" +kaggle_dataset_name = "nsrose7224/crowdedness-at-the-campus-gym" +gold_answer = "117.0" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "nsrose7224__crowdedness-at-the-campus-gym" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nsrose7224/crowdedness-at-the-campus-gym" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "117.0" +QUESTION = "What is the difference between the maximum number of people recorded and the median number of people 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/0081_472_81472707_qa_3/instruction.md b/tasks/0081_472_81472707_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..36af2158dd45f0d31eaa1df8c2624b979cc73768 --- /dev/null +++ b/tasks/0081_472_81472707_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 p-value was calculated to determine the statistical significance of the churn rate difference between month-to-month and one-year contracts? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_472_81472707_qa_3/task.toml b/tasks/0081_472_81472707_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6c810ef08701e45774c766d83569a92dd3924d63 --- /dev/null +++ b/tasks/0081_472_81472707_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0081_472_81472707_qa_3" +description = "What p-value was calculated to determine the statistical significance of the churn rate difference between month-to-month and one-year contracts?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0081/472/81472707.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "0.0" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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.0" +QUESTION = "What p-value was calculated to determine the statistical significance of the churn rate difference between month-to-month and one-year contracts?" +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_932_84932987_qa_5/instruction.md b/tasks/0084_932_84932987_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ab36705bb28b92259c5761ed88c464946f19c2aa --- /dev/null +++ b/tasks/0084_932_84932987_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 was the mean value of Insulin in the cleaned dataset after replacing zeros with the 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/0084_932_84932987_qa_5/task.toml b/tasks/0084_932_84932987_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b4f0ac00a252da900f07faa28e82750a2d747976 --- /dev/null +++ b/tasks/0084_932_84932987_qa_5/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0084_932_84932987_qa_5" +description = "What was the mean value of Insulin in the cleaned dataset after replacing zeros with the mean?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/932/84932987.ipynb_qa_5" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "155.823218" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 + +[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 = "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 = "155.5482233502538" +QUESTION = "What was the mean value of Insulin in the cleaned dataset after replacing zeros with the mean?" +REWARD_MODE = "numeric" +ATOL = "0.01" +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0085_343_85343577_qa_5/instruction.md b/tasks/0085_343_85343577_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ab07c95cc62b5aa1b2449fefd7e3df7d91480f35 --- /dev/null +++ b/tasks/0085_343_85343577_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): +- sudoku.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many non-trainable parameters exist in the Sudoku-solving CNN architecture? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_5/task.toml b/tasks/0085_343_85343577_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e4f07ec4f82b76b15a2af7685f79550e195e5c69 --- /dev/null +++ b/tasks/0085_343_85343577_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0085_343_85343577_qa_5" +description = "How many non-trainable parameters exist in the Sudoku-solving CNN architecture?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0085/343/85343577.ipynb_qa_5" +kaggle_dataset_name = "bryanpark/sudoku" +gold_answer = "256" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "256" +QUESTION = "How many non-trainable parameters exist in the Sudoku-solving CNN architecture?" +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_643_87643226_qa_5/instruction.md b/tasks/0087_643_87643226_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c46f996b2c99e0c946f8f2624805ff1e3d42962b --- /dev/null +++ b/tasks/0087_643_87643226_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 percentage of full payments made by customers according to the 'PRC_FULL_PAYMENT' 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/0087_643_87643226_qa_5/task.toml b/tasks/0087_643_87643226_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a79b6133a100c34c0e4d1936a0656ed45e3a8700 --- /dev/null +++ b/tasks/0087_643_87643226_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0087_643_87643226_qa_5" +description = "What is the average percentage of full payments made by customers according to the 'PRC_FULL_PAYMENT' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/643/87643226.ipynb_qa_5" +kaggle_dataset_name = "arjunbhasin2013/ccdata" +gold_answer = "0.153715" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "0.153715" +QUESTION = "What is the average percentage of full payments made by customers according to the 'PRC_FULL_PAYMENT' 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/0088_489_88489992_qa_2/instruction.md b/tasks/0088_489_88489992_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2fa6f2397e82bd1f6627b516f2264fe464f879d0 --- /dev/null +++ b/tasks/0088_489_88489992_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 range of the pupil-teacher ratio (PTRATIO) 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/0088_489_88489992_qa_2/task.toml b/tasks/0088_489_88489992_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6b3e31a5c129007de3f23f96de1179ab2afa3d94 --- /dev/null +++ b/tasks/0088_489_88489992_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0088_489_88489992_qa_2" +description = "What is the range of the pupil-teacher ratio (PTRATIO) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0088/489/88489992.ipynb_qa_2" +kaggle_dataset_name = "schirmerchad/bostonhoustingmlnd" +gold_answer = "9.4" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "9.4" +QUESTION = "What is the range of the pupil-teacher ratio (PTRATIO) 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/0089_051_89051135_qa_2/instruction.md b/tasks/0089_051_89051135_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..83dedfe670f4d7960769d80eb0c156ea1583c1a7 --- /dev/null +++ b/tasks/0089_051_89051135_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: +Which feature has the highest importance in predicting medical insurance charges according to the trained random forest 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/0089_051_89051135_qa_2/task.toml b/tasks/0089_051_89051135_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7d51b817a453ad1b8e48873dafb315a0dd9a254a --- /dev/null +++ b/tasks/0089_051_89051135_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0089_051_89051135_qa_2" +description = "Which feature has the highest importance in predicting medical insurance charges according to the trained random forest model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0089/051/89051135.ipynb_qa_2" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "smoker" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "smoker" +QUESTION = "Which feature has the highest importance in predicting medical insurance charges according to the trained random forest 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/0090_327_90327261_qa_4/instruction.md b/tasks/0090_327_90327261_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..123656e93341ead79581a85dfef78845bfece173 --- /dev/null +++ b/tasks/0090_327_90327261_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 accuracy of the Decision Tree classifier on the test set after feature selection and 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/0090_327_90327261_qa_4/task.toml b/tasks/0090_327_90327261_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..61d3204a233e31977c9fee7151b6d6572baa8ecc --- /dev/null +++ b/tasks/0090_327_90327261_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0090_327_90327261_qa_4" +description = "What is the accuracy of the Decision Tree classifier on the test set after feature selection and data preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0090/327/90327261.ipynb_qa_4" +kaggle_dataset_name = "primaryobjects/voicegender" +gold_answer = "96.00" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "primaryobjects__voicegender" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "primaryobjects/voicegender" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "96.00" +QUESTION = "What is the accuracy of the Decision Tree classifier on the test set after feature selection and data preprocessing?" +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/0094_688_94688742_qa_2/instruction.md b/tasks/0094_688_94688742_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2d2f5365505185e231607ae693692ac911a52ebd --- /dev/null +++ b/tasks/0094_688_94688742_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent video game genre in the dataset, and how many games belong to that genre? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_688_94688742_qa_2/task.toml b/tasks/0094_688_94688742_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0ffd11712d133f95ca14f6622458b5fc5d3b1ebd --- /dev/null +++ b/tasks/0094_688_94688742_qa_2/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0094_688_94688742_qa_2" +description = "What is the most frequent video game genre in the dataset, and how many games belong to that genre?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0094/688/94688742.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Action with 3,316 games" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 1 + +[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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Action with 3,316 games" +QUESTION = "What is the most frequent video game genre in the dataset, and how many games belong to that genre?" +REWARD_MODE = "exact_short" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0097_844_97844965_qa_2/instruction.md b/tasks/0097_844_97844965_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8db33f3141ae722b09326788747def7df54b4378 --- /dev/null +++ b/tasks/0097_844_97844965_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): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which cereal in Tier 3 has the highest fat percentage, and what is that percentage 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/0097_844_97844965_qa_2/task.toml b/tasks/0097_844_97844965_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..94e2a65c23a656c634d1f58e5873b0f0dbccf14e --- /dev/null +++ b/tasks/0097_844_97844965_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0097_844_97844965_qa_2" +description = "Which cereal in Tier 3 has the highest fat percentage, and what is that percentage value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0097/844/97844965.ipynb_qa_2" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "100% Natural Bran with 17.64%" +reward_mode_initial = "flexible" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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% Natural Bran with 17.64%" +QUESTION = "Which cereal in Tier 3 has the highest fat percentage, and what is that percentage value? Tier refers to the shelf column. Fat percentage = fat_grams / (weight_oz * 28.35) * 100, rounded to 2 decimal places." +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/0098_812_98812520_qa_1/instruction.md b/tasks/0098_812_98812520_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..00a9f7e3f933e3d05916d534ae2be79184d34798 --- /dev/null +++ b/tasks/0098_812_98812520_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 has the highest positive correlation with the price_range in the mobile price 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_812_98812520_qa_1/task.toml b/tasks/0098_812_98812520_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7b68c635c7912748ea9e4348f62d91383c123c3e --- /dev/null +++ b/tasks/0098_812_98812520_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0098_812_98812520_qa_1" +description = "Which feature has the highest positive correlation with the price_range in the mobile price dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0098/812/98812520.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "ram" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 has the highest positive correlation with the price_range in the mobile price 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/0100_969_100969953_qa_1/instruction.md b/tasks/0100_969_100969953_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..92e9d19881e18e37609a93e5b7aeae102fc7f55b --- /dev/null +++ b/tasks/0100_969_100969953_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 data cleaning steps, how many missing values remain 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/0100_969_100969953_qa_1/task.toml b/tasks/0100_969_100969953_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..842fdc7af011e3034e90a2ac00f38c6c53063e87 --- /dev/null +++ b/tasks/0100_969_100969953_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0100_969_100969953_qa_1" +description = "After data cleaning steps, how many missing values remain in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0100/969/100969953.ipynb_qa_1" +kaggle_dataset_name = "ninzaami/loan-predication" +gold_answer = "0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 data cleaning steps, how many missing values remain 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_138_104138961_qa_2/instruction.md b/tasks/0104_138_104138961_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..063dd1e425e1238c78a7222cd2e4d8d9c9e2f672 --- /dev/null +++ b/tasks/0104_138_104138961_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: +How many numerical variables in the dataset have outliers identified in the boxplot 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/0104_138_104138961_qa_2/task.toml b/tasks/0104_138_104138961_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fe5ea6295e0c67b54918e894e4f36c3f2f286f0c --- /dev/null +++ b/tasks/0104_138_104138961_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0104_138_104138961_qa_2" +description = "How many numerical variables in the dataset have outliers identified in the boxplot analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/138/104138961.ipynb_qa_2" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "30" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "29" +QUESTION = "How many numerical variables in the dataset have outliers identified in the boxplot 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/0104_333_104333921_qa_4/instruction.md b/tasks/0104_333_104333921_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..53f894abddd50d49fc1e6ca6d5bb8c674caf4531 --- /dev/null +++ b/tasks/0104_333_104333921_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 payment method is associated with the highest customer churn rate 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_333_104333921_qa_4/task.toml b/tasks/0104_333_104333921_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..658601e709ac4ab2219af92ac164daa4d9996928 --- /dev/null +++ b/tasks/0104_333_104333921_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0104_333_104333921_qa_4" +description = "What payment method is associated with the highest customer churn rate in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/333/104333921.ipynb_qa_4" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Electronic check" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "What payment method is associated with the highest customer churn rate 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/0104_955_104955589_qa_5/instruction.md b/tasks/0104_955_104955589_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3642d4299b36db18c90d84bf940e7f1262f1daec --- /dev/null +++ b/tasks/0104_955_104955589_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 correlation coefficient between age and BMI 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/0104_955_104955589_qa_5/task.toml b/tasks/0104_955_104955589_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..22468eda312393cef13156f27b450125368050ec --- /dev/null +++ b/tasks/0104_955_104955589_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0104_955_104955589_qa_5" +description = "What is the correlation coefficient between age and BMI variables in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/955/104955589.ipynb_qa_5" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "0.08" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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.08" +QUESTION = "What is the correlation coefficient between age and BMI variables 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_985_104985612_qa_4/instruction.md b/tasks/0104_985_104985612_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d391155e06ec45b17fb3842588184bc63276cf00 --- /dev/null +++ b/tasks/0104_985_104985612_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: +Which predictor variable in the linear regression model is not statistically significant at the 5% confidence level based on p-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/0104_985_104985612_qa_4/task.toml b/tasks/0104_985_104985612_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..718fb3ec2167cf7cad3760c1afbbb497eb5ae734 --- /dev/null +++ b/tasks/0104_985_104985612_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0104_985_104985612_qa_4" +description = "Which predictor variable in the linear regression model is not statistically significant at the 5% confidence level based on p-values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0104/985/104985612.ipynb_qa_4" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "ocean_proximity" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "ocean_proximity" +QUESTION = "Which predictor variable in the linear regression model is not statistically significant at the 5% confidence level based on p-values?" +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/0107_451_107451857_qa_4/task.toml b/tasks/0107_451_107451857_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..80e0ead9eecc1c18ac586b69fb7993a7f596a9cb --- /dev/null +++ b/tasks/0107_451_107451857_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0107_451_107451857_qa_4" +description = "What is the Pearson correlation coefficient between age and medical charges in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0107/451/107451857.ipynb_qa_4" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "0.299008" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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.299008" +QUESTION = "What is the Pearson correlation coefficient between age and medical charges 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/0109_091_109091369_qa_5/instruction.md b/tasks/0109_091_109091369_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..93fd56bc12f2b7165fb2ce129ac5c9b6d5d97c3e --- /dev/null +++ b/tasks/0109_091_109091369_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): +- 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 contract type is associated with the lowest customer churn rate according to the count 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/0109_091_109091369_qa_5/task.toml b/tasks/0109_091_109091369_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6473d6cd8d713d41eee458891c2020ef5eea3b39 --- /dev/null +++ b/tasks/0109_091_109091369_qa_5/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0109_091_109091369_qa_5" +description = "Which contract type is associated with the lowest customer churn rate according to the count plot analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0109/091/109091369.ipynb_qa_5" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Two year" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 2 + +[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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Two year" +QUESTION = "Which contract type is associated with the lowest customer churn rate according to the count plot analysis?" +REWARD_MODE = "exact_short" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0110_336_110336041_qa_2/instruction.md b/tasks/0110_336_110336041_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9478feb76c632ee239713e8202492cade3587ed6 --- /dev/null +++ b/tasks/0110_336_110336041_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: +How many missing values were present in the 'Unnamed: 32' column before it was dropped 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/0110_336_110336041_qa_2/task.toml b/tasks/0110_336_110336041_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3e2ef19d7ffa63d2cc592e4f6e09e588303e9018 --- /dev/null +++ b/tasks/0110_336_110336041_qa_2/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0110_336_110336041_qa_2" +description = "How many missing values were present in the 'Unnamed: 32' column before it was dropped from the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/336/110336041.ipynb_qa_2" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "569" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 + +[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 = "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 = "569" +QUESTION = "How many missing values were present in the 'Unnamed: 32' column before it was dropped from the dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0110_432_110432344_qa_4/instruction.md b/tasks/0110_432_110432344_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..99ff625fe1b283acd64666b5837a5f2cc1ad0553 --- /dev/null +++ b/tasks/0110_432_110432344_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): +- MER_T12_06.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 CO₂ emissions from coal and natural gas over the time period shown 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_432_110432344_qa_4/task.toml b/tasks/0110_432_110432344_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9383be562608dd33ce971f7efe0dc7343627e979 --- /dev/null +++ b/tasks/0110_432_110432344_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0110_432_110432344_qa_4" +description = "What is the correlation coefficient between CO₂ emissions from coal and natural gas over the time period shown in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/432/110432344.ipynb_qa_4" +kaggle_dataset_name = "txtrouble/carbon-emissions" +gold_answer = "-0.68" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "txtrouble__carbon-emissions" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "txtrouble/carbon-emissions" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.92" +QUESTION = "What is the correlation coefficient between CO₂ emissions from coal and natural gas over the time period shown in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.02" +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_717_110717969_qa_1/instruction.md b/tasks/0110_717_110717969_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a7b64ea2020d8528f48fb301ce9441eb48ac8a8a --- /dev/null +++ b/tasks/0110_717_110717969_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 contract type is associated with the lowest churn probability according to the model coefficients? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_717_110717969_qa_1/task.toml b/tasks/0110_717_110717969_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6f91efefbe33091b30749b4854963b3f81105690 --- /dev/null +++ b/tasks/0110_717_110717969_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0110_717_110717969_qa_1" +description = "Which contract type is associated with the lowest churn probability according to the model coefficients?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/717/110717969.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Two year" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "Two year" +QUESTION = "Which contract type is associated with the lowest churn probability according to the model coefficients?" +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/0110_937_110937668_qa_1/instruction.md b/tasks/0110_937_110937668_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28a2e630b81cd1657b339b97ea1ca4bc2474b44b --- /dev/null +++ b/tasks/0110_937_110937668_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): +- Automobile_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which variable has the strongest positive Spearman correlation with the price of automobiles 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_937_110937668_qa_1/task.toml b/tasks/0110_937_110937668_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2366e418120329503d1832f515a9c616e3b477ee --- /dev/null +++ b/tasks/0110_937_110937668_qa_1/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0110_937_110937668_qa_1" +description = "Which variable has the strongest positive Spearman correlation with the price of automobiles in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0110/937/110937668.ipynb_qa_1" +kaggle_dataset_name = "toramky/automobile-dataset" +gold_answer = "curb-weight" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 + +[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 = "toramky__automobile-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "toramky/automobile-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "curb-weight" +QUESTION = "Which variable has the strongest positive Spearman correlation with the price of automobiles in the dataset?" +REWARD_MODE = "exact_short" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0113_768_113768809_qa_2/instruction.md b/tasks/0113_768_113768809_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ecdc9076924cb3655346209fd4497d4246eee125 --- /dev/null +++ b/tasks/0113_768_113768809_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: +According to the Gradient Boosting model optimized for recall, which feature is the most important predictor of diabetes? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_768_113768809_qa_2/task.toml b/tasks/0113_768_113768809_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f4d1d4921cd1ad4b78e675c010fdc615c97af100 --- /dev/null +++ b/tasks/0113_768_113768809_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0113_768_113768809_qa_2" +description = "According to the Gradient Boosting model optimized for recall, which feature is the most important predictor of diabetes?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0113/768/113768809.ipynb_qa_2" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "According to the Gradient Boosting model optimized for recall, which feature is the most important predictor of diabetes?" +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_553_116553968_qa_1/instruction.md b/tasks/0116_553_116553968_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..32733798837b8c2e8ee44ed15519730487e93e6b --- /dev/null +++ b/tasks/0116_553_116553968_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 features in the dataset have the highest number of high correlations (correlation coefficient > 0.99) with other features after standardization? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_553_116553968_qa_1/task.toml b/tasks/0116_553_116553968_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..08beda6b95c9bd472b83f050309cf4669ca61f9a --- /dev/null +++ b/tasks/0116_553_116553968_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0116_553_116553968_qa_1" +description = "Which features in the dataset have the highest number of high correlations (correlation coefficient > 0.99) with other features after standardization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0116/553/116553968.ipynb_qa_1" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "radius_mean, perimeter_mean, radius_worst, perimeter_worst" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "radius_mean, perimeter_mean, radius_worst, perimeter_worst" +QUESTION = "Which features in the dataset have the highest number of high correlations (correlation coefficient > 0.99) with other features after standardization?" +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/0117_137_117137785_qa_2/instruction.md b/tasks/0117_137_117137785_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a35b904d136dcdbcbf8a0cbbdd835324d13925b2 --- /dev/null +++ b/tasks/0117_137_117137785_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): +- kidney_disease.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After imputation, how many missing values remain in the numerical columns 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/0117_137_117137785_qa_2/task.toml b/tasks/0117_137_117137785_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..aada86316b954fffe419ff3417fbac47144cd2bc --- /dev/null +++ b/tasks/0117_137_117137785_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0117_137_117137785_qa_2" +description = "After imputation, how many missing values remain in the numerical columns of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0117/137/117137785.ipynb_qa_2" +kaggle_dataset_name = "mansoordaku/ckdisease" +gold_answer = "0" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mansoordaku__ckdisease" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mansoordaku/ckdisease" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "After imputation, how many missing values remain in the numerical columns 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/0117_608_117608671_qa_4/instruction.md b/tasks/0117_608_117608671_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8fd178848c94dea92deef9d5566ec5d9711815f7 --- /dev/null +++ b/tasks/0117_608_117608671_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 correlation coefficient between the average number of rooms (RM) and the median house 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/0117_608_117608671_qa_4/task.toml b/tasks/0117_608_117608671_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..02ee02edf5e9fcd45a0c1840427d16bbba4c5f3d --- /dev/null +++ b/tasks/0117_608_117608671_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0117_608_117608671_qa_4" +description = "What is the correlation coefficient between the average number of rooms (RM) and the median house value (MEDV)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0117/608/117608671.ipynb_qa_4" +kaggle_dataset_name = "vikrishnan/boston-house-prices" +gold_answer = "0.7" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "vikrishnan__boston-house-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vikrishnan/boston-house-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.7" +QUESTION = "What is the correlation coefficient between the average number of rooms (RM) and the median house value (MEDV)?" +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/0122_770_122770918_qa_1/instruction.md b/tasks/0122_770_122770918_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d71f209543e94a53582d8d4196f3cd78d66f9768 --- /dev/null +++ b/tasks/0122_770_122770918_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 overall survival rate percentage of passengers in the Titanic 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_770_122770918_qa_1/task.toml b/tasks/0122_770_122770918_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..78d9740c23d3e4c5351d9f2627bad4d7cc0cdc61 --- /dev/null +++ b/tasks/0122_770_122770918_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0122_770_122770918_qa_1" +description = "What is the overall survival rate percentage of passengers in the Titanic dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0122/770/122770918.ipynb_qa_1" +kaggle_dataset_name = "abbasit/titanic" +gold_answer = "38.38" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abbasit__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abbasit/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "38.38" +QUESTION = "What is the overall survival rate percentage of passengers in the Titanic 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_418_124418283_qa_2/instruction.md b/tasks/0124_418_124418283_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..608813b9d3382b106b8ff761bcfe578cbe9c1be0 --- /dev/null +++ b/tasks/0124_418_124418283_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: +How many duplicate records were removed during the data preprocessing phase? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_418_124418283_qa_2/task.toml b/tasks/0124_418_124418283_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..45316a89f7532455bb02288c479e02e008d85d0b --- /dev/null +++ b/tasks/0124_418_124418283_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0124_418_124418283_qa_2" +description = "How many duplicate records were removed during the data preprocessing phase?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0124/418/124418283.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "240" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 the data preprocessing phase?" +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/0127_846_127846412_qa_2/instruction.md b/tasks/0127_846_127846412_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0c6a6ad95658067017445120b915d7c6050ee612 --- /dev/null +++ b/tasks/0127_846_127846412_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 absolute difference in average 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/0127_846_127846412_qa_2/task.toml b/tasks/0127_846_127846412_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..153c5d422cce8c5547485bd6b9d283563812187b --- /dev/null +++ b/tasks/0127_846_127846412_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0127_846_127846412_qa_2" +description = "What is the absolute difference in average 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 = "0127/846/127846412.ipynb_qa_2" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "23609.57" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "23609.57" +QUESTION = "What is the absolute difference in average medical charges between smokers and non-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/0128_659_128659556_qa_3/instruction.md b/tasks/0128_659_128659556_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9af9326dc08845b9d961ee6ccd11640b2badf37d --- /dev/null +++ b/tasks/0128_659_128659556_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: +How many ads had at least one Approved Conversion? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_659_128659556_qa_3/task.toml b/tasks/0128_659_128659556_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..36771b5067b20a8f97e4628cf669826b1357fcb9 --- /dev/null +++ b/tasks/0128_659_128659556_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0128_659_128659556_qa_3" +description = "How many ads had at least one Approved Conversion?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0128/659/128659556.ipynb_qa_3" +kaggle_dataset_name = "loveall/clicks-conversion-tracking" +gold_answer = "584" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "584" +QUESTION = "How many ads had at least one Approved Conversion?" +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/0133_533_133533460_qa_2/instruction.md b/tasks/0133_533_133533460_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..46011add885146719f0c30908303447b33dde8ee --- /dev/null +++ b/tasks/0133_533_133533460_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 was the average house price in December 2014 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/0133_533_133533460_qa_2/task.toml b/tasks/0133_533_133533460_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b6abf549e28d41314fa2bf329a72b7b75a69e491 --- /dev/null +++ b/tasks/0133_533_133533460_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0133_533_133533460_qa_2" +description = "What was the average house price in December 2014 based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0133/533/133533460.ipynb_qa_2" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "$538,000" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "524461.8667573079" +QUESTION = "What was the average house price in December 2014 based on 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/0136_845_136845893_qa_4/instruction.md b/tasks/0136_845_136845893_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..03d43f104387c049a64d9a621881a84f3cefe8cd --- /dev/null +++ b/tasks/0136_845_136845893_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: +After implementing class balancing, what is the exact ratio of ham to spam messages in the balanced 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/0136_845_136845893_qa_4/task.toml b/tasks/0136_845_136845893_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ad079e52ef336f48171f766b2e660ff7e5dd580a --- /dev/null +++ b/tasks/0136_845_136845893_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0136_845_136845893_qa_4" +description = "After implementing class balancing, what is the exact ratio of ham to spam messages in the balanced training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0136/845/136845893.ipynb_qa_4" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "1:1" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.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 = "1:1" +QUESTION = "After implementing class balancing, what is the exact ratio of ham to spam messages in the balanced 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/0136_961_136961156_qa_5/instruction.md b/tasks/0136_961_136961156_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..43ec338ff2f7c51dfadade080b62a725f93cd810 --- /dev/null +++ b/tasks/0136_961_136961156_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): +- column_2C_weka.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the R-squared value of the linear regression model predicting pelvic_tilt numeric from pelvic_incidence for Abnormal cases? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0136_961_136961156_qa_5/task.toml b/tasks/0136_961_136961156_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ab0a8cc4d5566f7a4003936b9f65dc8e4c88b2cb --- /dev/null +++ b/tasks/0136_961_136961156_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0136_961_136961156_qa_5" +description = "What is the R-squared value of the linear regression model predicting pelvic_tilt numeric from pelvic_incidence for Abnormal cases?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0136/961/136961156.ipynb_qa_5" +kaggle_dataset_name = "uciml/biomechanical-features-of-orthopedic-patients" +gold_answer = "0.32519970000015086" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__biomechanical-features-of-orthopedic-patients" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/biomechanical-features-of-orthopedic-patients" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.32519970000015086" +QUESTION = "What is the R-squared value of the linear regression model predicting pelvic_tilt numeric from pelvic_incidence for Abnormal cases?" +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/0138_103_138103420_qa_2/instruction.md b/tasks/0138_103_138103420_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..83ebccf731faee1ac4608164a1361d9a58eb133d --- /dev/null +++ b/tasks/0138_103_138103420_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 overall number of customers who have 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/0138_103_138103420_qa_2/task.toml b/tasks/0138_103_138103420_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..30e5f41417c4f3e3e898d57238bb9cb430983008 --- /dev/null +++ b/tasks/0138_103_138103420_qa_2/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0138_103_138103420_qa_2" +description = "What is the overall number of customers who have churned in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0138/103/138103420.ipynb_qa_2" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "1869" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 + +[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 = "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 = "What is the overall number of customers who have churned in the dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env]