diff --git a/tasks/0000_767_767688_qa_4/instruction.md b/tasks/0000_767_767688_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..354315fca65d99ac05ecb186d3c9aef04157c561 --- /dev/null +++ b/tasks/0000_767_767688_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +According to the scatter matrix analysis, which three features exhibited the highest linear correlation with each other in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact column names. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0000_767_767688_qa_4/task.toml b/tasks/0000_767_767688_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5cf8969d586cf83be95c4cc431231563811295e9 --- /dev/null +++ b/tasks/0000_767_767688_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0000_767_767688_qa_4" +description = "According to the scatter matrix analysis, which three features exhibited the highest linear correlation with each other in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/767/767688.ipynb_qa_4" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "perimeter_mean, area_mean, radius_mean" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "perimeter_mean, area_mean, radius_mean" +QUESTION = "According to the scatter matrix analysis, which three features exhibited the highest linear correlation with each other in the dataset?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0000_886_886039_qa_2/instruction.md b/tasks/0000_886_886039_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ef3a57389bccce34b6cf0814bef92db197e388a3 --- /dev/null +++ b/tasks/0000_886_886039_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- battles.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which defender was defeated the most times in the dataset, and how many times were they defeated? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, name first, plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0000_886_886039_qa_2/task.toml b/tasks/0000_886_886039_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fa1da7df5d035354726d8d5a8fc47bba7d58eda5 --- /dev/null +++ b/tasks/0000_886_886039_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0000_886_886039_qa_2" +description = "Which defender was defeated the most times in the dataset, and how many times were they defeated?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/886/886039.ipynb_qa_2" +kaggle_dataset_name = "mylesoneill/game-of-thrones" +gold_answer = "Robb Stark, 13" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mylesoneill__game-of-thrones" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mylesoneill/game-of-thrones" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Robb Stark, 13" +QUESTION = "Which defender was defeated the most times in the dataset, and how many times were they defeated?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_181_1181828_qa_4/instruction.md b/tasks/0001_181_1181828_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d0e19ac1975dd8e3d191d27dc0e7e4168d568421 --- /dev/null +++ b/tasks/0001_181_1181828_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): +- glass.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which model demonstrated the highest training accuracy but the lowest test accuracy in the comparison 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_181_1181828_qa_4/task.toml b/tasks/0001_181_1181828_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b408184a760dc2252e247f489e0ead188c94813a --- /dev/null +++ b/tasks/0001_181_1181828_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_181_1181828_qa_4" +description = "Which model demonstrated the highest training accuracy but the lowest test accuracy in the comparison analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/181/1181828.ipynb_qa_4" +kaggle_dataset_name = "uciml/glass" +gold_answer = "Decision Tree" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__glass" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/glass" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Decision Tree" +QUESTION = "Which model demonstrated the highest training accuracy but the lowest test accuracy in the comparison analysis?" +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_273_1273208_qa_2/instruction.md b/tasks/0001_273_1273208_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d9c303a4f3ee69c0fe00d6ef5f19c3092d358497 --- /dev/null +++ b/tasks/0001_273_1273208_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 undersampling, how many total rows are present in the balanced 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_273_1273208_qa_2/task.toml b/tasks/0001_273_1273208_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ca7a5e020afee0c8efe6292a8bfc7afd6a6c2b1d --- /dev/null +++ b/tasks/0001_273_1273208_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_273_1273208_qa_2" +description = "After undersampling, how many total rows are present in the balanced dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/273/1273208.ipynb_qa_2" +kaggle_dataset_name = "mlg-ulb/creditcardfraud" +gold_answer = "984" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mlg-ulb__creditcardfraud" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mlg-ulb/creditcardfraud" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "984" +QUESTION = "After undersampling, how many total rows are present in the balanced 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_341_1341821_qa_1/instruction.md b/tasks/0001_341_1341821_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9d610621ec88c981e363b91f42008c31f8585bd7 --- /dev/null +++ b/tasks/0001_341_1341821_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- 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 dual-type Pokémon combination across all generations, and what is its total count? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, keep the count as a plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_341_1341821_qa_1/task.toml b/tasks/0001_341_1341821_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..92d09f27e25c995ba3fee1c5ac188f35a5fa7da8 --- /dev/null +++ b/tasks/0001_341_1341821_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_341_1341821_qa_1" +description = "What is the most common dual-type Pokémon combination across all generations, and what is its total count?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/341/1341821.ipynb_qa_1" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "Normal/Flying, 24" +reward_mode_initial = "list" +package_tier = 3 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Normal/Flying, 24" +QUESTION = "What is the most common dual-type Pokémon combination across all generations, and what is its total count?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_473_1473187_qa_1/instruction.md b/tasks/0001_473_1473187_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f594774394ad8a58aeb7b50968d76e6b55b0196c --- /dev/null +++ b/tasks/0001_473_1473187_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest correlation coefficient among the features in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_473_1473187_qa_1/task.toml b/tasks/0001_473_1473187_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0a5e4d027f645ba8d82307e3c7012d37fae4b377 --- /dev/null +++ b/tasks/0001_473_1473187_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_473_1473187_qa_1" +description = "What is the highest correlation coefficient among the features in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/473/1473187.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.96" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.96" +QUESTION = "What is the highest correlation coefficient among the features in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_522_1522371_qa_2/instruction.md b/tasks/0001_522_1522371_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ed9fa447d837b0006d2224e10626304bf50f010f --- /dev/null +++ b/tasks/0001_522_1522371_qa_2/instruction.md @@ -0,0 +1,27 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mls-salaries-2007.csv +- mls-salaries-2008.csv +- mls-salaries-2009.csv +- mls-salaries-2010.csv +- mls-salaries-2011.csv +- mls-salaries-2012.csv +- mls-salaries-2013.csv +- mls-salaries-2014.csv +- mls-salaries-2015.csv +- mls-salaries-2016.csv +- mls-salaries-2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Who was the highest-paid player in the 2017 season, and what was their guaranteed compensation amount? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, name first, plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_522_1522371_qa_2/task.toml b/tasks/0001_522_1522371_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9783fdbc3fbadb0e896c0b1f4ed2054c9d23b7e3 --- /dev/null +++ b/tasks/0001_522_1522371_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_522_1522371_qa_2" +description = "Who was the highest-paid player in the 2017 season, and what was their guaranteed compensation amount?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/522/1522371.ipynb_qa_2" +kaggle_dataset_name = "crawford/us-major-league-soccer-salaries" +gold_answer = "Kaka, 7167500" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__us-major-league-soccer-salaries" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/us-major-league-soccer-salaries" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Kaka, 7167500" +QUESTION = "Who was the highest-paid player in the 2017 season, and what was their guaranteed compensation amount?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_522_1522371_qa_5/instruction.md b/tasks/0001_522_1522371_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0bca7970d0853dc15c950867c4db209e1f1ab977 --- /dev/null +++ b/tasks/0001_522_1522371_qa_5/instruction.md @@ -0,0 +1,27 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mls-salaries-2007.csv +- mls-salaries-2008.csv +- mls-salaries-2009.csv +- mls-salaries-2010.csv +- mls-salaries-2011.csv +- mls-salaries-2012.csv +- mls-salaries-2013.csv +- mls-salaries-2014.csv +- mls-salaries-2015.csv +- mls-salaries-2016.csv +- mls-salaries-2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which goalkeeper had the highest guaranteed compensation in the dataset, and what was the amount? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, name first, plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_522_1522371_qa_5/task.toml b/tasks/0001_522_1522371_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3b3cb7c3b8eddbf0eca4c3f359b0df2d7050beff --- /dev/null +++ b/tasks/0001_522_1522371_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_522_1522371_qa_5" +description = "Which goalkeeper had the highest guaranteed compensation in the dataset, and what was the amount?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/522/1522371.ipynb_qa_5" +kaggle_dataset_name = "crawford/us-major-league-soccer-salaries" +gold_answer = "Tim Howard, 2575000" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__us-major-league-soccer-salaries" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/us-major-league-soccer-salaries" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Tim Howard, 2575000" +QUESTION = "Which goalkeeper had the highest guaranteed compensation in the dataset, and what was the amount?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_527_1527039_qa_2/instruction.md b/tasks/0001_527_1527039_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..86b70e5db0e4dc631d846fb5a393b4186f8fc1bf --- /dev/null +++ b/tasks/0001_527_1527039_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): +- tarantino.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 recorded deaths across all Tarantino movies in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_527_1527039_qa_2/task.toml b/tasks/0001_527_1527039_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8e3946f3ac9a0ead1f04b0ec84e0179249160e8b --- /dev/null +++ b/tasks/0001_527_1527039_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_527_1527039_qa_2" +description = "What is the total number of recorded deaths across all Tarantino movies in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/527/1527039.ipynb_qa_2" +kaggle_dataset_name = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" +gold_answer = "190" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "fivethirtyeight__cuss-words-and-deaths-in-quentin-tarantino-films" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "190" +QUESTION = "What is the total number of recorded deaths across all Tarantino movies in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_527_1527054_qa_2/instruction.md b/tasks/0001_527_1527054_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8b383894489a557c1bdfe0683f934a9c095825b2 --- /dev/null +++ b/tasks/0001_527_1527054_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: +In which calendar year did the number of games receiving critic scores first exceed 10, marking the beginning of widespread critic score data collection? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_527_1527054_qa_2/task.toml b/tasks/0001_527_1527054_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..64d89aa91d4fff616435c7599f37c1057ea90725 --- /dev/null +++ b/tasks/0001_527_1527054_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_527_1527054_qa_2" +description = "In which calendar year did the number of games receiving critic scores first exceed 10, marking the beginning of widespread critic score data collection?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/527/1527054.ipynb_qa_2" +kaggle_dataset_name = "rush4ratio/video-game-sales-with-ratings" +gold_answer = "1996" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rush4ratio__video-game-sales-with-ratings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rush4ratio/video-game-sales-with-ratings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1996" +QUESTION = "In which calendar year did the number of games receiving critic scores first exceed 10, marking the beginning of widespread critic score data collection?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_527_1527054_qa_5/instruction.md b/tasks/0001_527_1527054_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2348f4194dfb866ff759d3b03ca9b4f7b33ce469 --- /dev/null +++ b/tasks/0001_527_1527054_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): +- Video_Games_Sales_as_at_22_Dec_2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest global sales value achieved by a Nintendo-published game in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_527_1527054_qa_5/task.toml b/tasks/0001_527_1527054_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..98e060b5a86f033685fef84fc8c7a294a0e01568 --- /dev/null +++ b/tasks/0001_527_1527054_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_527_1527054_qa_5" +description = "What is the highest global sales value achieved by a Nintendo-published game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/527/1527054.ipynb_qa_5" +kaggle_dataset_name = "rush4ratio/video-game-sales-with-ratings" +gold_answer = "82.53" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rush4ratio__video-game-sales-with-ratings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rush4ratio/video-game-sales-with-ratings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82.53" +QUESTION = "What is the highest global sales value achieved by a Nintendo-published game in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_541_1541002_qa_2/instruction.md b/tasks/0001_541_1541002_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d36262f499ab650e02124558bd99e2dc8c5daa14 --- /dev/null +++ b/tasks/0001_541_1541002_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 profitable genre by total global sales as shown in the genre sales 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_541_1541002_qa_2/task.toml b/tasks/0001_541_1541002_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3fbc417b6cd3a8248171daf70c54b9e21bc3709d --- /dev/null +++ b/tasks/0001_541_1541002_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_541_1541002_qa_2" +description = "What is the most profitable genre by total global sales as shown in the genre sales analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/541/1541002.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Action" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Action" +QUESTION = "What is the most profitable genre by total global sales as shown in the genre sales 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_570_1570948_qa_4/instruction.md b/tasks/0001_570_1570948_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..98009426cc29d5047c3ec50b38032fb590db21bc --- /dev/null +++ b/tasks/0001_570_1570948_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Based on the violin plot, which species has the most variable petal length? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_570_1570948_qa_4/task.toml b/tasks/0001_570_1570948_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a7b5aac2607d996c99330e5059e70beca0d8ed82 --- /dev/null +++ b/tasks/0001_570_1570948_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_570_1570948_qa_4" +description = "Based on the violin plot, which species has the most variable petal length?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/570/1570948.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-virginica" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Iris-virginica" +QUESTION = "Based on the violin plot, which species has the most variable petal length?" +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_661_1661005_qa_1/instruction.md b/tasks/0001_661_1661005_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..233ca226f3dbcfc7ee52cdc9be6d14485dd62da1 --- /dev/null +++ b/tasks/0001_661_1661005_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- DigiDB_digimonlist.csv +- DigiDB_movelist.csv +- DigiDB_supportlist.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum HP at level 50 among all Digimon 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_661_1661005_qa_1/task.toml b/tasks/0001_661_1661005_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..de5760d97b622f7c6b315f3fb0f14dcfacc7ebfc --- /dev/null +++ b/tasks/0001_661_1661005_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_661_1661005_qa_1" +description = "What is the maximum HP at level 50 among all Digimon in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/661/1661005.ipynb_qa_1" +kaggle_dataset_name = "rtatman/digidb" +gold_answer = "2080" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rtatman__digidb" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rtatman/digidb" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2080" +QUESTION = "What is the maximum HP at level 50 among all Digimon 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_959_1959663_qa_3/instruction.md b/tasks/0001_959_1959663_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dfc78fc10bd3c84e1608c0b00b53ce1cb90a2289 --- /dev/null +++ b/tasks/0001_959_1959663_qa_3/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Train.csv +- Test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After removing outliers in 'Item_Outlet_Sales' using the 0.95 quantile threshold, what was the new maximum value of this 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/0001_959_1959663_qa_3/task.toml b/tasks/0001_959_1959663_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..de7db8bb14c7c78d6aa782e24da6dabfad15928e --- /dev/null +++ b/tasks/0001_959_1959663_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_959_1959663_qa_3" +description = "After removing outliers in 'Item_Outlet_Sales' using the 0.95 quantile threshold, what was the new maximum value of this variable?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/959/1959663.ipynb_qa_3" +kaggle_dataset_name = "nishanta/big-mart-sales" +gold_answer = "5522.81" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "nishanta__big-mart-sales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nishanta/big-mart-sales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5522.81" +QUESTION = "After removing outliers in 'Item_Outlet_Sales' using the 0.95 quantile threshold, what was the new maximum value of this variable?" +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_990_1990392_qa_4/instruction.md b/tasks/0001_990_1990392_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c8272c30868b967e93f88249a1079d97a0543859 --- /dev/null +++ b/tasks/0001_990_1990392_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: +What is the average score of wines that exceed 95 points in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_990_1990392_qa_4/task.toml b/tasks/0001_990_1990392_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9069c01a8a9f8c2c998001c9c411eb6192a6d4ce --- /dev/null +++ b/tasks/0001_990_1990392_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_990_1990392_qa_4" +description = "What is the average score of wines that exceed 95 points in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/990/1990392.ipynb_qa_4" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "96.66" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "96.66" +QUESTION = "What is the average score of wines that exceed 95 points 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/0002_264_2264461_qa_1/instruction.md b/tasks/0002_264_2264461_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cae1a08eba24b2fa6954c05be6c680abc49363c3 --- /dev/null +++ b/tasks/0002_264_2264461_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): +- acs2015_county_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which state has the highest number of counties in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0002_264_2264461_qa_1/task.toml b/tasks/0002_264_2264461_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f962dc3012f9f374339391f3eed0a9d3ea321d9e --- /dev/null +++ b/tasks/0002_264_2264461_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0002_264_2264461_qa_1" +description = "Which state has the highest number of counties in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/264/2264461.ipynb_qa_1" +kaggle_dataset_name = "muonneutrino/us-census-demographic-data" +gold_answer = "Texas" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "muonneutrino__us-census-demographic-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "muonneutrino/us-census-demographic-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Texas" +QUESTION = "Which state has the highest number of counties 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/0010_909_10909980_qa_3/instruction.md b/tasks/0010_909_10909980_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ef5134bca8f3e1ef10f144e830eaf8d31c497c02 --- /dev/null +++ b/tasks/0010_909_10909980_qa_3/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- 2015.csv +- 2016.csv +- 2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which factor has the strongest negative correlation with the Happiness Rank in the 2017 dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0010_909_10909980_qa_3/task.toml b/tasks/0010_909_10909980_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..90d3737f59c4204f20e5eb178314586fd72d3ecd --- /dev/null +++ b/tasks/0010_909_10909980_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0010_909_10909980_qa_3" +description = "Which factor has the strongest negative correlation with the Happiness Rank in the 2017 dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0010/909/10909980.ipynb_qa_3" +kaggle_dataset_name = "unsdsn/world-happiness" +gold_answer = "Economy (GDP per Capita)" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "unsdsn__world-happiness" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "unsdsn/world-happiness" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Economy (GDP per Capita)" +QUESTION = "Which factor has the strongest negative correlation with the Happiness Rank in the 2017 dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0011_970_11970593_qa_2/instruction.md b/tasks/0011_970_11970593_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..63d6f20c434bf3e6a5625baf0e76c03554539d00 --- /dev/null +++ b/tasks/0011_970_11970593_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): +- fake.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many entries in the dataset have a spam_score value of exactly 0? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0011_970_11970593_qa_2/task.toml b/tasks/0011_970_11970593_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3dc95aaeb57d8036c41e4fe398711e16a9f599f0 --- /dev/null +++ b/tasks/0011_970_11970593_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0011_970_11970593_qa_2" +description = "How many entries in the dataset have a spam_score value of exactly 0?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/970/11970593.ipynb_qa_2" +kaggle_dataset_name = "mrisdal/fake-news" +gold_answer = "11632" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mrisdal__fake-news" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mrisdal/fake-news" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11632" +QUESTION = "How many entries in the dataset have a spam_score value of exactly 0?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0012_941_12941575_qa_2/instruction.md b/tasks/0012_941_12941575_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b2e1964e4579ea2f01868770095c9b143571a4f5 --- /dev/null +++ b/tasks/0012_941_12941575_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest attrition rate observed among employees with different job involvement levels? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0012_941_12941575_qa_2/task.toml b/tasks/0012_941_12941575_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9c3058dfbedd974a654253728e6330bb6fd24bd0 --- /dev/null +++ b/tasks/0012_941_12941575_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0012_941_12941575_qa_2" +description = "What is the highest attrition rate observed among employees with different job involvement levels?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0012/941/12941575.ipynb_qa_2" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "33.73" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "33.73" +QUESTION = "What is the highest attrition rate observed among employees with different job involvement levels?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0013_613_13613426_qa_5/instruction.md b/tasks/0013_613_13613426_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..22d2eda5bd3ba56923663ad59ccf0081aa6ed1bf --- /dev/null +++ b/tasks/0013_613_13613426_qa_5/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the class distribution of the Species attribute in the Iris dataset, as determined by the group size analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as comma-separated : pairs, with the exact class names and counts. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0013_613_13613426_qa_5/task.toml b/tasks/0013_613_13613426_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dd20c19e64df41e24ed77c666d479e31888dafe2 --- /dev/null +++ b/tasks/0013_613_13613426_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0013_613_13613426_qa_5" +description = "What is the class distribution of the Species attribute in the Iris dataset, as determined by the group size analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/613/13613426.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-setosa: 50, Iris-versicolor: 50, Iris-virginica: 50" +reward_mode_initial = "list" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Iris-setosa: 50, Iris-versicolor: 50, Iris-virginica: 50" +QUESTION = "What is the class distribution of the Species attribute in the Iris dataset, as determined by the group size analysis?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0013_733_13733964_qa_1/instruction.md b/tasks/0013_733_13733964_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..860286b24a7be58943519abd430dc79ca01c48db --- /dev/null +++ b/tasks/0013_733_13733964_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest range among the continuous 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/0013_733_13733964_qa_1/task.toml b/tasks/0013_733_13733964_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3a7dee364f29f72d50bbabbfde0ef1d879dd860f --- /dev/null +++ b/tasks/0013_733_13733964_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0013_733_13733964_qa_1" +description = "What is the highest range among the continuous variables in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/733/13733964.ipynb_qa_1" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "18497" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "18497" +QUESTION = "What is the highest range among the continuous variables 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/0013_748_13748223_qa_1/instruction.md b/tasks/0013_748_13748223_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..52e0f02d9594cf2fd262847f2dc738514773f726 --- /dev/null +++ b/tasks/0013_748_13748223_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 video game has the highest global sales according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0013_748_13748223_qa_1/task.toml b/tasks/0013_748_13748223_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d4a3fbbb9eb5ceee63d7f6ecac0203801a2de8d4 --- /dev/null +++ b/tasks/0013_748_13748223_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0013_748_13748223_qa_1" +description = "Which video game has the highest global sales according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/748/13748223.ipynb_qa_1" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Wii Sports" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Wii Sports" +QUESTION = "Which video game has the highest global sales according to the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0013_884_13884693_qa_1/instruction.md b/tasks/0013_884_13884693_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..38ac2f63abce88f7991e0a82201a8274959ea726 --- /dev/null +++ b/tasks/0013_884_13884693_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the number of diabetic patients in the dataset based on the Outcome distribution? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0013_884_13884693_qa_1/task.toml b/tasks/0013_884_13884693_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..81ecf993b647225856554cce56b065188fa9d786 --- /dev/null +++ b/tasks/0013_884_13884693_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0013_884_13884693_qa_1" +description = "What is the number of diabetic patients in the dataset based on the Outcome distribution?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/884/13884693.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "268" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "268" +QUESTION = "What is the number of diabetic patients in the dataset based on the Outcome distribution?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0014_089_14089673_qa_5/instruction.md b/tasks/0014_089_14089673_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a8e7e2569f149ed53e6f0e972871b085dfaef0e0 --- /dev/null +++ b/tasks/0014_089_14089673_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): +- operations.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 bombing missions recorded in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0014_089_14089673_qa_5/task.toml b/tasks/0014_089_14089673_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5bb4652767ff21df4e6f94e3483e6d72577b10fe --- /dev/null +++ b/tasks/0014_089_14089673_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0014_089_14089673_qa_5" +description = "What is the total number of bombing missions recorded in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/089/14089673.ipynb_qa_5" +kaggle_dataset_name = "usaf/world-war-ii" +gold_answer = "178281" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "usaf__world-war-ii" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "usaf/world-war-ii" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "178281" +QUESTION = "What is the total number of bombing missions recorded in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0014_312_14312130_qa_4/instruction.md b/tasks/0014_312_14312130_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f5af3b767a4bb9362d3bc559f609a6edce654464 --- /dev/null +++ b/tasks/0014_312_14312130_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: +Which country was specifically identified for experimental testing due to having both high infant deaths and low HepatitisB immunization coverage? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0014_312_14312130_qa_4/task.toml b/tasks/0014_312_14312130_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..73dd79252d81eb7c8091a08425ce63a76374acaa --- /dev/null +++ b/tasks/0014_312_14312130_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0014_312_14312130_qa_4" +description = "Which country was specifically identified for experimental testing due to having both high infant deaths and low HepatitisB immunization coverage?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/312/14312130.ipynb_qa_4" +kaggle_dataset_name = "kumarajarshi/life-expectancy-who" +gold_answer = "India" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kumarajarshi__life-expectancy-who" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "India" +QUESTION = "Which country was specifically identified for experimental testing due to having both high infant deaths and low HepatitisB immunization coverage?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0014_933_14933483_qa_3/instruction.md b/tasks/0014_933_14933483_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9a345dc8d04ceded5905fe7ddcac25dff355c3d0 --- /dev/null +++ b/tasks/0014_933_14933483_qa_3/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature exhibits the highest mean value across all samples, and what is that mean? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, feature name first, keep decimals). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0014_933_14933483_qa_3/task.toml b/tasks/0014_933_14933483_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..103376e331b7480346510d8650403280bc6ec6a0 --- /dev/null +++ b/tasks/0014_933_14933483_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0014_933_14933483_qa_3" +description = "Which feature exhibits the highest mean value across all samples, and what is that mean?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/933/14933483.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "SepalLengthCm with a mean of 5.843333." +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "SepalLengthCm with a mean of 5.843333." +QUESTION = "Which feature exhibits the highest mean value across all samples, and what is that mean?" +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/0015_050_15050710_qa_1/instruction.md b/tasks/0015_050_15050710_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..287fc183f8bf8eaa56fe67d322aecfb9b8b14539 --- /dev/null +++ b/tasks/0015_050_15050710_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest positive correlation with the 'Outcome' variable in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0015_050_15050710_qa_1/task.toml b/tasks/0015_050_15050710_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ac986b13d0c1f9b8aea102d5447062593fe09d9b --- /dev/null +++ b/tasks/0015_050_15050710_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0015_050_15050710_qa_1" +description = "Which feature has the highest positive correlation with the 'Outcome' variable in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0015/050/15050710.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Glucose" +QUESTION = "Which feature has the highest positive correlation with the 'Outcome' variable 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/0016_136_16136283_qa_1/instruction.md b/tasks/0016_136_16136283_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a73a01f82a44a1c7ab646d2efde090f488ab90c0 --- /dev/null +++ b/tasks/0016_136_16136283_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): +- Amazon_Unlocked_Mobile.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of reviews classified as "Positively Rated" after filtering out neutral reviews (rating = 3)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0016_136_16136283_qa_1/task.toml b/tasks/0016_136_16136283_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b8aca5328b5148276825d6618e518b80ac44940f --- /dev/null +++ b/tasks/0016_136_16136283_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0016_136_16136283_qa_1" +description = "What is the percentage of reviews classified as \"Positively Rated\" after filtering out neutral reviews (rating = 3)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/136/16136283.ipynb_qa_1" +kaggle_dataset_name = "nehasontakke/amazon-unlocked-mobilecsv" +gold_answer = "74.8" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "nehasontakke__amazon-unlocked-mobilecsv" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nehasontakke/amazon-unlocked-mobilecsv" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "74.8" +QUESTION = "What is the percentage of reviews classified as \"Positively Rated\" after filtering out neutral reviews (rating = 3)?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0016_714_16714217_qa_1/instruction.md b/tasks/0016_714_16714217_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c87f1cb9fc65963b3e8e155593392f6c271526be --- /dev/null +++ b/tasks/0016_714_16714217_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- auto-mpg.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many rows were removed from the dataset due to missing 'horsepower' 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/0016_714_16714217_qa_1/task.toml b/tasks/0016_714_16714217_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..98bd0b093549007b4eb63a4b27cc531eef09382e --- /dev/null +++ b/tasks/0016_714_16714217_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0016_714_16714217_qa_1" +description = "How many rows were removed from the dataset due to missing 'horsepower' values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/714/16714217.ipynb_qa_1" +kaggle_dataset_name = "uciml/autompg-dataset" +gold_answer = "6" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__autompg-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/autompg-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many rows were removed from the dataset due to missing 'horsepower' 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/0016_985_16985676_qa_3/instruction.md b/tasks/0016_985_16985676_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b76232f9c8ac5d6d92e177a09ed32f372f790791 --- /dev/null +++ b/tasks/0016_985_16985676_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): +- Video_Games_Sales_as_at_22_Dec_2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which game is most similar to "Pokemon Red/Pokemon Blue" based on genre similarity, excluding the game itself? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0016_985_16985676_qa_3/task.toml b/tasks/0016_985_16985676_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0492cc5160992ff9b146eee67aacc1d5ad79db1a --- /dev/null +++ b/tasks/0016_985_16985676_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0016_985_16985676_qa_3" +description = "Which game is most similar to \"Pokemon Red/Pokemon Blue\" based on genre similarity, excluding the game itself?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/985/16985676.ipynb_qa_3" +kaggle_dataset_name = "rush4ratio/video-game-sales-with-ratings" +gold_answer = "Pokemon Gold/Pokemon Silver" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rush4ratio__video-game-sales-with-ratings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rush4ratio/video-game-sales-with-ratings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Pokemon Gold/Pokemon Silver" +QUESTION = "Which game is most similar to \"Pokemon Red/Pokemon Blue\" based on genre similarity, excluding the game itself?" +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/0018_493_18493579_qa_1/instruction.md b/tasks/0018_493_18493579_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..938dab193dc8db6cf4121f1d8485967876b2c885 --- /dev/null +++ b/tasks/0018_493_18493579_qa_1/instruction.md @@ -0,0 +1,22 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- races.csv +- drivers.csv +- circuits.csv +- constructors.csv +- qualifying.csv +- results.csv +- status.csv +- lapTimes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many races did Lewis Hamilton win in his Formula 1 career 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/0018_493_18493579_qa_1/task.toml b/tasks/0018_493_18493579_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2af6728e45e158572f1a56ce93ace6cf8b76ff5d --- /dev/null +++ b/tasks/0018_493_18493579_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0018_493_18493579_qa_1" +description = "How many races did Lewis Hamilton win in his Formula 1 career based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0018/493/18493579.ipynb_qa_1" +kaggle_dataset_name = "cjgdev/formula-1-race-data-19502017" +gold_answer = "62" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "cjgdev__formula-1-race-data-19502017" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "cjgdev/formula-1-race-data-19502017" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "62" +QUESTION = "How many races did Lewis Hamilton win in his Formula 1 career based on 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/0018_510_18510968_qa_2/instruction.md b/tasks/0018_510_18510968_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..62cb36f391b6fceb38711d880ed1d785510c2f4e --- /dev/null +++ b/tasks/0018_510_18510968_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- titanic.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which passenger class (pclass) has the lowest survival rate according to the countplot 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/0018_510_18510968_qa_2/task.toml b/tasks/0018_510_18510968_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a0ae2a1e896efb5edc1f9e64a10c6f2def6170b6 --- /dev/null +++ b/tasks/0018_510_18510968_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0018_510_18510968_qa_2" +description = "Which passenger class (pclass) has the lowest survival rate according to the countplot analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0018/510/18510968.ipynb_qa_2" +kaggle_dataset_name = "jiuzhang/titanic-subset" +gold_answer = "3" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "jiuzhang__titanic-subset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "jiuzhang/titanic-subset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "Which passenger class (pclass) has the lowest survival rate according to the countplot analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0020_613_20613845_qa_4/instruction.md b/tasks/0020_613_20613845_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5fd2e3def7dd01dd91eca583998af8e9d81b15e0 --- /dev/null +++ b/tasks/0020_613_20613845_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum value of the 'radius_mean' feature in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0020_613_20613845_qa_4/task.toml b/tasks/0020_613_20613845_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..91243c75b2b941f785e8ca1c02cedefdc6e963e8 --- /dev/null +++ b/tasks/0020_613_20613845_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0020_613_20613845_qa_4" +description = "What is the maximum value of the 'radius_mean' feature in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/613/20613845.ipynb_qa_4" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "28.11" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "28.11" +QUESTION = "What is the maximum value of the 'radius_mean' feature in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0022_169_22169428_qa_5/instruction.md b/tasks/0022_169_22169428_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a83d7d06ab7f4febec35086fa7f369e15d5aa9d6 --- /dev/null +++ b/tasks/0022_169_22169428_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 mean absolute error (MAE) of the logistic regression model's predictions for shot make percentage between 22 and 27.3 feet? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_169_22169428_qa_5/task.toml b/tasks/0022_169_22169428_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6e34b50a8e78563aafb1f76dffcc14292280ef62 --- /dev/null +++ b/tasks/0022_169_22169428_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0022_169_22169428_qa_5" +description = "What is the mean absolute error (MAE) of the logistic regression model's predictions for shot make percentage between 22 and 27.3 feet?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0022/169/22169428.ipynb_qa_5" +kaggle_dataset_name = "dansbecker/nba-shot-logs" +gold_answer = "0.0199" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "dansbecker__nba-shot-logs" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dansbecker/nba-shot-logs" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.0199" +QUESTION = "What is the mean absolute error (MAE) of the logistic regression model's predictions for shot make percentage between 22 and 27.3 feet?" +REWARD_MODE = "flexible" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0023_468_23468316_qa_3/instruction.md b/tasks/0023_468_23468316_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a6e999d58e32f68a2621f5ee0370ea132ddf285b --- /dev/null +++ b/tasks/0023_468_23468316_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique countries are present in the nativeCountry column of the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_468_23468316_qa_3/task.toml b/tasks/0023_468_23468316_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9550777657abe87cffc8763174cfc9a05f181a9f --- /dev/null +++ b/tasks/0023_468_23468316_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0023_468_23468316_qa_3" +description = "How many unique countries are present in the nativeCountry column of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/468/23468316.ipynb_qa_3" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "42" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "42" +QUESTION = "How many unique countries are present in the nativeCountry column of the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0023_598_23598239_qa_1/instruction.md b/tasks/0023_598_23598239_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..325358f9d5b9948801a396dc8ccdeeb903865357 --- /dev/null +++ b/tasks/0023_598_23598239_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Crime1.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common crime category in the dataset, and how many incidents does it account for? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, category first, plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_598_23598239_qa_1/task.toml b/tasks/0023_598_23598239_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3b5b4477deca4da80ff8ace41660356d32d68f98 --- /dev/null +++ b/tasks/0023_598_23598239_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0023_598_23598239_qa_1" +description = "What is the most common crime category in the dataset, and how many incidents does it account for?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/598/23598239.ipynb_qa_1" +kaggle_dataset_name = "yasiradnan/crime-classifcication" +gold_answer = "LARCENY/THEFT, 223" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "yasiradnan__crime-classifcication" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "yasiradnan/crime-classifcication" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "LARCENY/THEFT, 223" +QUESTION = "What is the most common crime category in the dataset, and how many incidents does it account for?" +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/0023_721_23721684_qa_5/instruction.md b/tasks/0023_721_23721684_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..42369d375b4a5ff6f5cd27c9dc48579a17697fed --- /dev/null +++ b/tasks/0023_721_23721684_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average rating of cereals produced by Nabisco (manufacturer N)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_721_23721684_qa_5/task.toml b/tasks/0023_721_23721684_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9c44b877a8ed2fd3b676d01c43fa6ac7d703c5a3 --- /dev/null +++ b/tasks/0023_721_23721684_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0023_721_23721684_qa_5" +description = "What is the average rating of cereals produced by Nabisco (manufacturer N)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/721/23721684.ipynb_qa_5" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "67.97" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "67.97" +QUESTION = "What is the average rating of cereals produced by Nabisco (manufacturer N)?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0023_931_23931431_qa_1/instruction.md b/tasks/0023_931_23931431_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..25a04231cb1e5fef124aa22d6a14b38264d23168 --- /dev/null +++ b/tasks/0023_931_23931431_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 percentage of messages in the dataset are classified as spam (Category 0)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_931_23931431_qa_1/task.toml b/tasks/0023_931_23931431_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fbee3c2bd7f8b63214a7f510772810ea4fb9e02c --- /dev/null +++ b/tasks/0023_931_23931431_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0023_931_23931431_qa_1" +description = "What percentage of messages in the dataset are classified as spam (Category 0)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/931/23931431.ipynb_qa_1" +kaggle_dataset_name = "team-ai/spam-text-message-classification" +gold_answer = "13.4" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "13.4" +QUESTION = "What percentage of messages in the dataset are classified as spam (Category 0)?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0024_069_24069916_qa_1/instruction.md b/tasks/0024_069_24069916_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..71383c461e7c6d59fb8796ff1e9b6b52d59d63c7 --- /dev/null +++ b/tasks/0024_069_24069916_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): +- xAPI-Edu-Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which nationality has the highest number of students in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0024_069_24069916_qa_1/task.toml b/tasks/0024_069_24069916_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..afb7f1be5ec9ff201a377b2f87491924f9c49aab --- /dev/null +++ b/tasks/0024_069_24069916_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0024_069_24069916_qa_1" +description = "Which nationality has the highest number of students in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/069/24069916.ipynb_qa_1" +kaggle_dataset_name = "aljarah/xAPI-Edu-Data" +gold_answer = "KW" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "aljarah__xAPI-Edu-Data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "aljarah/xAPI-Edu-Data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "KW" +QUESTION = "Which nationality has the highest number of students 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/0024_285_24285301_qa_2/instruction.md b/tasks/0024_285_24285301_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..79ca50fd1ca207d7787def4e71b0bf194f6e406e --- /dev/null +++ b/tasks/0024_285_24285301_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): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest correlation coefficient observed between any two numeric variables in the dataset, excluding perfect correlations (1.0)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0024_285_24285301_qa_2/task.toml b/tasks/0024_285_24285301_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0eb2f96ab2481c88b933cc297956b48c3839b297 --- /dev/null +++ b/tasks/0024_285_24285301_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0024_285_24285301_qa_2" +description = "What is the highest correlation coefficient observed between any two numeric variables in the dataset, excluding perfect correlations (1.0)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/285/24285301.ipynb_qa_2" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "0.975094" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.975094" +QUESTION = "What is the highest correlation coefficient observed between any two numeric variables in the dataset, excluding perfect correlations (1.0)?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0024_315_24315892_qa_3/instruction.md b/tasks/0024_315_24315892_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2622ae65fbaa288ce82860b56a98e6624a8e34d8 --- /dev/null +++ b/tasks/0024_315_24315892_qa_3/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What are the median values of axillary nodes (axil_nodes) for patients with survival status 1 (5+ years) and survival status 2 (<5 years)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the two median values in the order given (survival status 1, then survival status 2), as plain integers. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_315_24315892_qa_3/task.toml b/tasks/0024_315_24315892_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ed679371e2907622f61e2a035e50a49a468bbea7 --- /dev/null +++ b/tasks/0024_315_24315892_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0024_315_24315892_qa_3" +description = "What are the median values of axillary nodes (axil_nodes) for patients with survival status 1 (5+ years) and survival status 2 (<5 years)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/315/24315892.ipynb_qa_3" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "0, 4" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0, 4" +QUESTION = "What are the median values of axillary nodes (axil_nodes) for patients with survival status 1 (5+ years) and survival status 2 (<5 years)?" +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/0024_829_24829447_qa_4/instruction.md b/tasks/0024_829_24829447_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fad452562b944cc403b43cd06824ccf457897f48 --- /dev/null +++ b/tasks/0024_829_24829447_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature was removed from the dataset due to low variance (minimal difference between mean, min, 25%, 50%, 75% 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/0024_829_24829447_qa_4/task.toml b/tasks/0024_829_24829447_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..eeb0ca60562ec91995f3647f475fd6b46f931f81 --- /dev/null +++ b/tasks/0024_829_24829447_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0024_829_24829447_qa_4" +description = "Which feature was removed from the dataset due to low variance (minimal difference between mean, min, 25%, 50%, 75% values)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/829/24829447.ipynb_qa_4" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "density" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "density" +QUESTION = "Which feature was removed from the dataset due to low variance (minimal difference between mean, min, 25%, 50%, 75% 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/0025_204_25204322_qa_4/instruction.md b/tasks/0025_204_25204322_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e94c579d9319785e1f8b230618aeafe384098610 --- /dev/null +++ b/tasks/0025_204_25204322_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- pokemon.csv +- combats.csv +- tests.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 Type 2 column before data cleaning? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0025_204_25204322_qa_4/task.toml b/tasks/0025_204_25204322_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..24114425b30d132019138944ee4f98d9e200b681 --- /dev/null +++ b/tasks/0025_204_25204322_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0025_204_25204322_qa_4" +description = "How many missing values were present in the Type 2 column before data cleaning?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0025/204/25204322.ipynb_qa_4" +kaggle_dataset_name = "terminus7/pokemon-challenge" +gold_answer = "386" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "terminus7__pokemon-challenge" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "386" +QUESTION = "How many missing values were present in the Type 2 column before data cleaning?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0025_274_25274016_qa_4/instruction.md b/tasks/0025_274_25274016_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..675bba7eed7490379d8876151312c8d333ce92d6 --- /dev/null +++ b/tasks/0025_274_25274016_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): +- training.1600000.processed.noemoticon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of tweets in the dataset are classified as neutral (target 2)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0025_274_25274016_qa_4/task.toml b/tasks/0025_274_25274016_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0e083ce04b6a76ac9d3c12d80e64669d8238ddbd --- /dev/null +++ b/tasks/0025_274_25274016_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0025_274_25274016_qa_4" +description = "What percentage of tweets in the dataset are classified as neutral (target 2)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0025/274/25274016.ipynb_qa_4" +kaggle_dataset_name = "kazanova/sentiment140" +gold_answer = "0" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kazanova__sentiment140" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kazanova/sentiment140" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "What percentage of tweets in the dataset are classified as neutral (target 2)?" +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/0026_354_26354042_qa_1/instruction.md b/tasks/0026_354_26354042_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..de5beab18bb72cc9f4e444be4b755d12c65bfcca --- /dev/null +++ b/tasks/0026_354_26354042_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Salary_Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the interquartile range (IQR) of years of experience 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/0026_354_26354042_qa_1/task.toml b/tasks/0026_354_26354042_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ca02d0644f0bd2f48b3ca381c3422b7608a4dc48 --- /dev/null +++ b/tasks/0026_354_26354042_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0026_354_26354042_qa_1" +description = "What is the interquartile range (IQR) of years of experience in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/354/26354042.ipynb_qa_1" +kaggle_dataset_name = "karthickveerakumar/salary-data-simple-linear-regression" +gold_answer = "4.5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "karthickveerakumar__salary-data-simple-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "karthickveerakumar/salary-data-simple-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4.5" +QUESTION = "What is the interquartile range (IQR) of years of experience 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/0026_826_26826730_qa_1/instruction.md b/tasks/0026_826_26826730_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0ddc46c6e72df0736f151f5faa77d7745b06cc0c --- /dev/null +++ b/tasks/0026_826_26826730_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest chi-square score for predicting employee attrition according to the feature selection analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0026_826_26826730_qa_1/task.toml b/tasks/0026_826_26826730_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c2d371572b041e52bc09e2228adad833012724cf --- /dev/null +++ b/tasks/0026_826_26826730_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0026_826_26826730_qa_1" +description = "Which feature has the highest chi-square score for predicting employee attrition according to the feature selection analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/826/26826730.ipynb_qa_1" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "MonthlyIncome" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "MonthlyIncome" +QUESTION = "Which feature has the highest chi-square score for predicting employee attrition according to the feature selection 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/0026_836_26836336_qa_1/instruction.md b/tasks/0026_836_26836336_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7a1a8b66c2c55e87e5ad6c2a700421d787a77bef --- /dev/null +++ b/tasks/0026_836_26836336_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many features remain in the dataset after removing the 'id' and 'Unnamed: 32' columns? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0026_836_26836336_qa_1/task.toml b/tasks/0026_836_26836336_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a813bcc5aca486813ee3ef2799e9a4577ecb6d85 --- /dev/null +++ b/tasks/0026_836_26836336_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0026_836_26836336_qa_1" +description = "How many features remain in the dataset after removing the 'id' and 'Unnamed: 32' columns?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/836/26836336.ipynb_qa_1" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "31" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__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 = "31" +QUESTION = "How many features remain in the dataset after removing the 'id' and 'Unnamed: 32' columns?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0026_997_26997571_qa_2/instruction.md b/tasks/0026_997_26997571_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5a8433f4aeb8f6d6c32999e390a8c9dfca76501b --- /dev/null +++ b/tasks/0026_997_26997571_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_first150k.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 wine price and points 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/0026_997_26997571_qa_2/task.toml b/tasks/0026_997_26997571_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b34a1b45f28d8aeaf44cf4146195928c320e87f3 --- /dev/null +++ b/tasks/0026_997_26997571_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0026_997_26997571_qa_2" +description = "What is the Pearson correlation coefficient between wine price and points in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/997/26997571.ipynb_qa_2" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "0.459863" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.459863" +QUESTION = "What is the Pearson correlation coefficient between wine price and points 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/0026_997_26997571_qa_4/instruction.md b/tasks/0026_997_26997571_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..602cbeb957d4a88281b4795250117eb7025bee66 --- /dev/null +++ b/tasks/0026_997_26997571_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_first150k.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the lowest average wine points score among all countries represented in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0026_997_26997571_qa_4/task.toml b/tasks/0026_997_26997571_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..55064da6fbd566ae6abfdb4dab4e0870a799e4b2 --- /dev/null +++ b/tasks/0026_997_26997571_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0026_997_26997571_qa_4" +description = "What is the lowest average wine points score among all countries represented in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/997/26997571.ipynb_qa_4" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "82" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "82" +QUESTION = "What is the lowest average wine points score among all countries represented in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0028_443_28443310_qa_4/instruction.md b/tasks/0028_443_28443310_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4a72d12cf72c97f5f988c4150ae4d91897870dd5 --- /dev/null +++ b/tasks/0028_443_28443310_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- pokemon_alopez247.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the calculated Catch Rate percentage for Charizard after normalization to a 0-100% scale? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0028_443_28443310_qa_4/task.toml b/tasks/0028_443_28443310_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0b8658ab7f167ad7e4e287f153f80e6ca33985d8 --- /dev/null +++ b/tasks/0028_443_28443310_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0028_443_28443310_qa_4" +description = "What is the calculated Catch Rate percentage for Charizard after normalization to a 0-100% scale?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/443/28443310.ipynb_qa_4" +kaggle_dataset_name = "alopez247/pokemon" +gold_answer = "18.37" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "alopez247__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "alopez247/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "18.37" +QUESTION = "What is the calculated Catch Rate percentage for Charizard after normalization to a 0-100% scale?" +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/0028_513_28513384_qa_1/instruction.md b/tasks/0028_513_28513384_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..89be0e898c87a44ca54d7c9eb88d1dffe691b71f --- /dev/null +++ b/tasks/0028_513_28513384_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which month shows the highest average house price based on the sales data 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/0028_513_28513384_qa_1/task.toml b/tasks/0028_513_28513384_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b24a61d16a6bd91b081e618bef12f60e86bd6b2e --- /dev/null +++ b/tasks/0028_513_28513384_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0028_513_28513384_qa_1" +description = "Which month shows the highest average house price based on the sales data analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/513/28513384.ipynb_qa_1" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "April" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "April" +QUESTION = "Which month shows the highest average house price based on the sales data 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/0029_108_29108182_qa_1/instruction.md b/tasks/0029_108_29108182_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fbd3e3465649a366608b6a48fa55a335a25b9de4 --- /dev/null +++ b/tasks/0029_108_29108182_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset shows the highest correlation with the Outcome variable indicating diabetes diagnosis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0029_108_29108182_qa_1/task.toml b/tasks/0029_108_29108182_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..01d3114a6867a737df3842e75f3be9de51041c75 --- /dev/null +++ b/tasks/0029_108_29108182_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0029_108_29108182_qa_1" +description = "Which feature in the dataset shows the highest correlation with the Outcome variable indicating diabetes diagnosis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0029/108/29108182.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Glucose" +QUESTION = "Which feature in the dataset shows the highest correlation with the Outcome variable indicating diabetes diagnosis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0030_348_30348412_qa_2/instruction.md b/tasks/0030_348_30348412_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..55c1417766acf937a4de71edfa039edc6a89542e --- /dev/null +++ b/tasks/0030_348_30348412_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_u6lujuX_CVtuZ9i (1).csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the property area with the highest number of loan applications? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0030_348_30348412_qa_2/task.toml b/tasks/0030_348_30348412_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dfdd020164cbd8b63e7cf66541810e738764c997 --- /dev/null +++ b/tasks/0030_348_30348412_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0030_348_30348412_qa_2" +description = "What is the property area with the highest number of loan applications?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/348/30348412.ipynb_qa_2" +kaggle_dataset_name = "ninzaami/loan-predication" +gold_answer = "Semiurban" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "ninzaami__loan-predication" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ninzaami/loan-predication" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Semiurban" +QUESTION = "What is the property area with the highest number of loan applications?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0030_804_30804903_qa_1/instruction.md b/tasks/0030_804_30804903_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e3a82b560fb89459a91e2aa12b243bd7394b76e6 --- /dev/null +++ b/tasks/0030_804_30804903_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which physical property of red wine has the strongest positive correlation with its quality according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0030_804_30804903_qa_1/task.toml b/tasks/0030_804_30804903_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b44190b542f4d54e667a259e7671c5f229885847 --- /dev/null +++ b/tasks/0030_804_30804903_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0030_804_30804903_qa_1" +description = "Which physical property of red wine has the strongest positive correlation with its quality according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/804/30804903.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "Alcohol" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Alcohol" +QUESTION = "Which physical property of red wine has the strongest positive correlation with its quality according to the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0030_890_30890976_qa_2/instruction.md b/tasks/0030_890_30890976_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..788fcc2e97e55279e03d6b25336bf7209676f73a --- /dev/null +++ b/tasks/0030_890_30890976_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv +- gender_submission.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum age value in the combined training and test datasets used for normalization? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0030_890_30890976_qa_2/task.toml b/tasks/0030_890_30890976_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..842a1cb28dcd31506ddf4f83e828b37f2ccf9077 --- /dev/null +++ b/tasks/0030_890_30890976_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0030_890_30890976_qa_2" +description = "What is the maximum age value in the combined training and test datasets used for normalization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/890/30890976.ipynb_qa_2" +kaggle_dataset_name = "rashigoel/titanic-machine-learning-from-disaster" +gold_answer = "80.0" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rashigoel__titanic-machine-learning-from-disaster" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rashigoel/titanic-machine-learning-from-disaster" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "80.0" +QUESTION = "What is the maximum age value in the combined training and test datasets used for normalization?" +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/0030_890_30890976_qa_5/instruction.md b/tasks/0030_890_30890976_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1769120a6a50945eb74b906e2e49dcea61893b8d --- /dev/null +++ b/tasks/0030_890_30890976_qa_5/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv +- gender_submission.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the macro average F1-score of the XGBoost model on the validation set? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0030_890_30890976_qa_5/task.toml b/tasks/0030_890_30890976_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e91471a7ca4eaad31ac71454f1089f69f69679a9 --- /dev/null +++ b/tasks/0030_890_30890976_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0030_890_30890976_qa_5" +description = "What is the macro average F1-score of the XGBoost model on the validation set?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/890/30890976.ipynb_qa_5" +kaggle_dataset_name = "rashigoel/titanic-machine-learning-from-disaster" +gold_answer = "0.83" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rashigoel__titanic-machine-learning-from-disaster" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rashigoel/titanic-machine-learning-from-disaster" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.83" +QUESTION = "What is the macro average F1-score of the XGBoost model on the validation set?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0031_089_31089222_qa_2/instruction.md b/tasks/0031_089_31089222_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6b2958683ec630434ac9fc0465d358d6190a3bb4 --- /dev/null +++ b/tasks/0031_089_31089222_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: +After applying the 90th percentile outlier treatment, what was the skewness value for the 'residual sugar' 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/0031_089_31089222_qa_2/task.toml b/tasks/0031_089_31089222_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..85ec57019cbde88136e58493c9a4f8c4cffc4f6d --- /dev/null +++ b/tasks/0031_089_31089222_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0031_089_31089222_qa_2" +description = "After applying the 90th percentile outlier treatment, what was the skewness value for the 'residual sugar' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/089/31089222.ipynb_qa_2" +kaggle_dataset_name = "maitree/wine-quality-selection" +gold_answer = "0.811384" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "maitree__wine-quality-selection" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "maitree/wine-quality-selection" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.811384" +QUESTION = "After applying the 90th percentile outlier treatment, what was the skewness value for the 'residual sugar' 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/0031_829_31829521_qa_1/instruction.md b/tasks/0031_829_31829521_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c6fb2fb517be16358c1b474de7b1d5584d9bd899 --- /dev/null +++ b/tasks/0031_829_31829521_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest Attack stat among first generation legendary Pokémon? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0031_829_31829521_qa_1/task.toml b/tasks/0031_829_31829521_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dffc969eee36ae7459f2f8cbd6f66fc4e568456a --- /dev/null +++ b/tasks/0031_829_31829521_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0031_829_31829521_qa_1" +description = "What is the highest Attack stat among first generation legendary Pokémon?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/829/31829521.ipynb_qa_1" +kaggle_dataset_name = "terminus7/pokemon-challenge" +gold_answer = "190" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "terminus7__pokemon-challenge" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "190" +QUESTION = "What is the highest Attack stat among first generation legendary Pokémon?" +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_014_32014924_qa_3/instruction.md b/tasks/0032_014_32014924_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2dc1ad3b7e5473a542293845f8ba7a1fb3137011 --- /dev/null +++ b/tasks/0032_014_32014924_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): +- column_3C_weka.csv +- 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 mean pelvic incidence angle for patients diagnosed with Spondylolisthesis 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_014_32014924_qa_3/task.toml b/tasks/0032_014_32014924_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..39b313f09cedf0e11d19be41570c1d10e7aa7377 --- /dev/null +++ b/tasks/0032_014_32014924_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_014_32014924_qa_3" +description = "What is the mean pelvic incidence angle for patients diagnosed with Spondylolisthesis in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/014/32014924.ipynb_qa_3" +kaggle_dataset_name = "uciml/biomechanical-features-of-orthopedic-patients" +gold_answer = "71.51" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__biomechanical-features-of-orthopedic-patients" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/biomechanical-features-of-orthopedic-patients" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "71.51" +QUESTION = "What is the mean pelvic incidence angle for patients diagnosed with Spondylolisthesis in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_317_32317961_qa_1/instruction.md b/tasks/0032_317_32317961_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..76fa7748a0b9263acdcfdd6ba0afb9b4825735e9 --- /dev/null +++ b/tasks/0032_317_32317961_qa_1/instruction.md @@ -0,0 +1,19 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- ShareRaceByCity.csv +- PoliceKillingsUS.csv +- PercentOver25CompletedHighSchool.csv +- PercentagePeopleBelowPovertyLevel.csv +- MedianHouseholdIncome2015.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which U.S. state has the highest average poverty rate 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/0032_317_32317961_qa_1/task.toml b/tasks/0032_317_32317961_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ff19e8e1bd56373a1f752ae86e87b20b34422ca9 --- /dev/null +++ b/tasks/0032_317_32317961_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_317_32317961_qa_1" +description = "Which U.S. state has the highest average poverty rate based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/317/32317961.ipynb_qa_1" +kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us" +gold_answer = "Mississippi" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kwullum__fatal-police-shootings-in-the-us" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Mississippi" +QUESTION = "Which U.S. state has the highest average poverty rate based on the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_340_32340135_qa_5/instruction.md b/tasks/0032_340_32340135_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..725b522cff5d17c575894139842d4ec853ff0e14 --- /dev/null +++ b/tasks/0032_340_32340135_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): +- voted-kaggle-dataset.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 datasets in the original Kaggle dataset collection analyzed in this study? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_340_32340135_qa_5/task.toml b/tasks/0032_340_32340135_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9f7a3fb6c2dc3a9f51eb45c88e68434b02b143d0 --- /dev/null +++ b/tasks/0032_340_32340135_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_340_32340135_qa_5" +description = "What is the total number of datasets in the original Kaggle dataset collection analyzed in this study?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/340/32340135.ipynb_qa_5" +kaggle_dataset_name = "canggih/voted-kaggle-dataset" +gold_answer = "2150" +reward_mode_initial = "numeric" +package_tier = 3 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "canggih__voted-kaggle-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "canggih/voted-kaggle-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2150" +QUESTION = "What is the total number of datasets in the original Kaggle dataset collection analyzed in this study?" +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_386_32386426_qa_2/instruction.md b/tasks/0032_386_32386426_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1c43e7ed2da467df5c29a6f23f4644cb3b537387 --- /dev/null +++ b/tasks/0032_386_32386426_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): +- bank.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What specific age ranges show the highest likelihood of term deposit subscription based on the KDE analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0032_386_32386426_qa_2/task.toml b/tasks/0032_386_32386426_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c41ffda70e1059ab327784e3d50ae62aa43a75c0 --- /dev/null +++ b/tasks/0032_386_32386426_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0032_386_32386426_qa_2" +description = "What specific age ranges show the highest likelihood of term deposit subscription based on the KDE analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/386/32386426.ipynb_qa_2" +kaggle_dataset_name = "janiobachmann/bank-marketing-dataset" +gold_answer = "below 30 and above 60" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "janiobachmann__bank-marketing-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "below 30 and above 60" +QUESTION = "What specific age ranges show the highest likelihood of term deposit subscription based on the KDE analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_442_32442771_qa_3/instruction.md b/tasks/0032_442_32442771_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4034b2c5962b072b931536fe1758d0bc4021ad82 --- /dev/null +++ b/tasks/0032_442_32442771_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 chocolate bars in the dataset use blended bean types in their production? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_442_32442771_qa_3/task.toml b/tasks/0032_442_32442771_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..567d69717be96a3a4f8e3c6f98205d011c4410c8 --- /dev/null +++ b/tasks/0032_442_32442771_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0032_442_32442771_qa_3" +description = "How many chocolate bars in the dataset use blended bean types in their production?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/442/32442771.ipynb_qa_3" +kaggle_dataset_name = "rtatman/chocolate-bar-ratings" +gold_answer = "103" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rtatman__chocolate-bar-ratings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rtatman/chocolate-bar-ratings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "103" +QUESTION = "How many chocolate bars in the dataset use blended bean types in their production?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0033_684_33684962_qa_3/instruction.md b/tasks/0033_684_33684962_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e2ea3e8dd4c0786b41c9c3a651d91e4139ce2297 --- /dev/null +++ b/tasks/0033_684_33684962_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): +- glass.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Are the test accuracies of the Decision Tree and Random Forest models identical based on the analysis of the normalized dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0033_684_33684962_qa_3/task.toml b/tasks/0033_684_33684962_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..13f3bfa1d811e4660980c57a9b50dd32bce303a1 --- /dev/null +++ b/tasks/0033_684_33684962_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0033_684_33684962_qa_3" +description = "Are the test accuracies of the Decision Tree and Random Forest models identical based on the analysis of the normalized dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/684/33684962.ipynb_qa_3" +kaggle_dataset_name = "uciml/glass" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__glass" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/glass" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Are the test accuracies of the Decision Tree and Random Forest models identical based on the analysis of the normalized dataset?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_170_34170800_qa_2/instruction.md b/tasks/0034_170_34170800_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7610ae3e368896c91e37fa704c03807c6effd188 --- /dev/null +++ b/tasks/0034_170_34170800_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 percentage of the dataset had missing values in the Outlet_Size column before imputation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0034_170_34170800_qa_2/task.toml b/tasks/0034_170_34170800_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e64d3505a874e53641f9863d3d4b685c6c28e756 --- /dev/null +++ b/tasks/0034_170_34170800_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0034_170_34170800_qa_2" +description = "What percentage of the dataset had missing values in the Outlet_Size column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/170/34170800.ipynb_qa_2" +kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data" +gold_answer = "28.28" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "28.28" +QUESTION = "What percentage of the dataset had missing values in the Outlet_Size column before imputation?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_339_34339717_qa_5/instruction.md b/tasks/0034_339_34339717_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1068d6919e3b925e175d7911946de3d5e3ed36b0 --- /dev/null +++ b/tasks/0034_339_34339717_qa_5/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which mean feature in the dataset has the highest standard deviation, and what is its value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, keep decimals). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0034_339_34339717_qa_5/task.toml b/tasks/0034_339_34339717_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..94f5632a88d6bad70e2247849b9a3a46e36b336c --- /dev/null +++ b/tasks/0034_339_34339717_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0034_339_34339717_qa_5" +description = "Which mean feature in the dataset has the highest standard deviation, and what is its value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/339/34339717.ipynb_qa_5" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "area_mean, 351.914" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__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 = "area_mean, 351.914" +QUESTION = "Which mean feature in the dataset has the highest standard deviation, and what is its value?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_380_34380054_qa_2/instruction.md b/tasks/0034_380_34380054_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8d3f628afa97a11fbffbc6f652fd965fe1307cb0 --- /dev/null +++ b/tasks/0034_380_34380054_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 coefficient of the run difference (RD) in the linear regression model predicting wins from RD? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_380_34380054_qa_2/task.toml b/tasks/0034_380_34380054_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..df3b56b56280c9a26923d4d33fc68d7ad23238e3 --- /dev/null +++ b/tasks/0034_380_34380054_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0034_380_34380054_qa_2" +description = "What is the coefficient of the run difference (RD) in the linear regression model predicting wins from RD?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/380/34380054.ipynb_qa_2" +kaggle_dataset_name = "wduckett/moneyball-mlb-stats-19622012" +gold_answer = "0.1058" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "wduckett__moneyball-mlb-stats-19622012" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wduckett/moneyball-mlb-stats-19622012" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.1058" +QUESTION = "What is the coefficient of the run difference (RD) in the linear regression model predicting wins from RD?" +REWARD_MODE = "flexible" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_726_34726167_qa_2/instruction.md b/tasks/0034_726_34726167_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..790ffd6b17fac60b9699f53c8c54a8af7b49158a --- /dev/null +++ b/tasks/0034_726_34726167_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): +- sonar.all-data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many features in the dataset have a minimum value of exactly 0.0000? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_726_34726167_qa_2/task.toml b/tasks/0034_726_34726167_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bb1ac19bc2ff29f5ce8f99bdca45f8aca7cd2842 --- /dev/null +++ b/tasks/0034_726_34726167_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0034_726_34726167_qa_2" +description = "How many features in the dataset have a minimum value of exactly 0.0000?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/726/34726167.ipynb_qa_2" +kaggle_dataset_name = "mattcarter865/mines-vs-rocks" +gold_answer = "9" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mattcarter865__mines-vs-rocks" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mattcarter865/mines-vs-rocks" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "9" +QUESTION = "How many features in the dataset have a minimum value of exactly 0.0000?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_912_34912092_qa_3/instruction.md b/tasks/0034_912_34912092_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..786eb70df722c53840da8323dce12273041c208b --- /dev/null +++ b/tasks/0034_912_34912092_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- german_credit_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the dataset has missing values in the "Checking account" column? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0034_912_34912092_qa_3/task.toml b/tasks/0034_912_34912092_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c53d1125d43685642123cb142b817b8a067e51b8 --- /dev/null +++ b/tasks/0034_912_34912092_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0034_912_34912092_qa_3" +description = "What percentage of the dataset has missing values in the \"Checking account\" column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/912/34912092.ipynb_qa_3" +kaggle_dataset_name = "uciml/german-credit" +gold_answer = "39.4" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__german-credit" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/german-credit" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "39.4" +QUESTION = "What percentage of the dataset has missing values in the \"Checking account\" column?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_171_35171975_qa_3/instruction.md b/tasks/0035_171_35171975_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..22623f14561e5e2a74bef0e700a3847bdc74a2e6 --- /dev/null +++ b/tasks/0035_171_35171975_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of individuals in the dataset are diagnosed with diabetes based on the Outcome variable? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_171_35171975_qa_3/task.toml b/tasks/0035_171_35171975_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0c2b3859b9fcf79389298f4b4ebfe8ffc2566624 --- /dev/null +++ b/tasks/0035_171_35171975_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_171_35171975_qa_3" +description = "What percentage of individuals in the dataset are diagnosed with diabetes based on the Outcome variable?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/171/35171975.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "34.8958" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "34.8958" +QUESTION = "What percentage of individuals in the dataset are diagnosed with diabetes based on the Outcome variable?" +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_171_35171975_qa_4/instruction.md b/tasks/0035_171_35171975_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..569eae09bb1aef5a5bd89ab922953fce3bf1f0eb --- /dev/null +++ b/tasks/0035_171_35171975_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which variable shows the most extreme leptokurtic distribution, and what is its kurtosis value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, variable name first, keep decimals). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_171_35171975_qa_4/task.toml b/tasks/0035_171_35171975_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0e603986f5ba120942ff45f52bcc4f2a1b7f9735 --- /dev/null +++ b/tasks/0035_171_35171975_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0035_171_35171975_qa_4" +description = "Which variable shows the most extreme leptokurtic distribution, and what is its kurtosis value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/171/35171975.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Insulin, 7.214260" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Insulin, 7.214260" +QUESTION = "Which variable shows the most extreme leptokurtic distribution, and what is its kurtosis value?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_236_35236553_qa_4/instruction.md b/tasks/0035_236_35236553_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..30ac7d7ddbce3013276ec66fc740ae5f987e4bdf --- /dev/null +++ b/tasks/0035_236_35236553_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): +- LeagueofLegends.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average game length in the 2018 LCK season included 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_236_35236553_qa_4/task.toml b/tasks/0035_236_35236553_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5b6e5ac71aef68ef9b0df5e573392683f65c0368 --- /dev/null +++ b/tasks/0035_236_35236553_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0035_236_35236553_qa_4" +description = "What is the average game length in the 2018 LCK season included in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/236/35236553.ipynb_qa_4" +kaggle_dataset_name = "chuckephron/leagueoflegends" +gold_answer = "40.98" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "chuckephron__leagueoflegends" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "chuckephron/leagueoflegends" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "40.98" +QUESTION = "What is the average game length in the 2018 LCK season included 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/0035_789_35789775_qa_3/instruction.md b/tasks/0035_789_35789775_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28bd6dfd9693c98af92969d40a6f6c36fb33a534 --- /dev/null +++ b/tasks/0035_789_35789775_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which publisher achieved the highest total sales in the Japanese region? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_789_35789775_qa_3/task.toml b/tasks/0035_789_35789775_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4b6694f87135cdc07ec0606980d39e9f3aa315be --- /dev/null +++ b/tasks/0035_789_35789775_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_789_35789775_qa_3" +description = "Which publisher achieved the highest total sales in the Japanese region?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/789/35789775.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Nintendo" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Nintendo" +QUESTION = "Which publisher achieved the highest total sales in the Japanese region?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_789_35789775_qa_5/instruction.md b/tasks/0035_789_35789775_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ed9f43643e2f36cb4a927d554d1e75b4c3dc98c0 --- /dev/null +++ b/tasks/0035_789_35789775_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the platform with the highest average sales in the European region? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_789_35789775_qa_5/task.toml b/tasks/0035_789_35789775_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0722e8e812cbe3d9ff183691c1e00340d4bc7192 --- /dev/null +++ b/tasks/0035_789_35789775_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_789_35789775_qa_5" +description = "What is the platform with the highest average sales in the European region?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/789/35789775.ipynb_qa_5" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "GB" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "GB" +QUESTION = "What is the platform with the highest average sales in the European region?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0037_718_37718370_qa_1/instruction.md b/tasks/0037_718_37718370_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1606f8a0801dd830697571ca4b7453136d3317ef --- /dev/null +++ b/tasks/0037_718_37718370_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of customers in the dataset have churned? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_718_37718370_qa_1/task.toml b/tasks/0037_718_37718370_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..abe432b618318e2aa000199d877a56a6daa1db19 --- /dev/null +++ b/tasks/0037_718_37718370_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0037_718_37718370_qa_1" +description = "What percentage of customers in the dataset have churned?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/718/37718370.ipynb_qa_1" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "26.5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "26.5" +QUESTION = "What percentage of customers in the dataset have churned?" +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/0037_995_37995698_qa_1/instruction.md b/tasks/0037_995_37995698_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cf6c7c94d8deee918ab2e5217afe193f360bcd39 --- /dev/null +++ b/tasks/0037_995_37995698_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Are the three Iris species classes balanced 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_995_37995698_qa_1/task.toml b/tasks/0037_995_37995698_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..67e36676664baad4e008279424f7a887d1c68dee --- /dev/null +++ b/tasks/0037_995_37995698_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0037_995_37995698_qa_1" +description = "Are the three Iris species classes balanced in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/995/37995698.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Are the three Iris species classes balanced in the dataset?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0038_509_38509914_qa_4/instruction.md b/tasks/0038_509_38509914_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fa88ac156b4c6b64f13a0f9179c61e20be924cd2 --- /dev/null +++ b/tasks/0038_509_38509914_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: +How many false positives (ham messages incorrectly classified as spam) are present in the test set using the Naive Bayes 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/0038_509_38509914_qa_4/task.toml b/tasks/0038_509_38509914_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..651ae8c73354033c897398ed590dbc0dd990e0a4 --- /dev/null +++ b/tasks/0038_509_38509914_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0038_509_38509914_qa_4" +description = "How many false positives (ham messages incorrectly classified as spam) are present in the test set using the Naive Bayes model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/509/38509914.ipynb_qa_4" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "8" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__sms-spam-collection-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "8" +QUESTION = "How many false positives (ham messages incorrectly classified as spam) are present in the test set using the Naive Bayes 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/0038_821_38821052_qa_5/instruction.md b/tasks/0038_821_38821052_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9d4d34f416fb265d4962651cc3a42471fe70e766 --- /dev/null +++ b/tasks/0038_821_38821052_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After outlier handling, which ocean proximity category has the highest number of housing records 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_821_38821052_qa_5/task.toml b/tasks/0038_821_38821052_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9662cc4278549b5b07bada23e76cdb73484b06ff --- /dev/null +++ b/tasks/0038_821_38821052_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0038_821_38821052_qa_5" +description = "After outlier handling, which ocean proximity category has the highest number of housing records in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/821/38821052.ipynb_qa_5" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "<1H OCEAN" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "<1H OCEAN" +QUESTION = "After outlier handling, which ocean proximity category has the highest number of housing records 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/0039_243_39243552_qa_4/instruction.md b/tasks/0039_243_39243552_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3e8b6c7d61c69a95764a27893538f2cdbc19ecb7 --- /dev/null +++ b/tasks/0039_243_39243552_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 percentage of the total monthly charges is lost due to customer churn? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_243_39243552_qa_4/task.toml b/tasks/0039_243_39243552_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..392dddccbdbeb118652295c0b07711a1243d93cd --- /dev/null +++ b/tasks/0039_243_39243552_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0039_243_39243552_qa_4" +description = "What percentage of the total monthly charges is lost due to customer churn?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/243/39243552.ipynb_qa_4" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "30.5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "30.5" +QUESTION = "What percentage of the total monthly charges is lost due to customer churn?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_409_39409376_qa_2/instruction.md b/tasks/0039_409_39409376_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e8a51e6ace0a3885c82579e57463bd6580f5b07b --- /dev/null +++ b/tasks/0039_409_39409376_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest correlation coefficient between any two numerical features in the iris dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_409_39409376_qa_2/task.toml b/tasks/0039_409_39409376_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a3a60e025fdc6ca8193f3dfab46a8585fbbb2a49 --- /dev/null +++ b/tasks/0039_409_39409376_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_409_39409376_qa_2" +description = "What is the highest correlation coefficient between any two numerical features in the iris dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/409/39409376.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.962757" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.962757" +QUESTION = "What is the highest correlation coefficient between any two numerical features in the iris 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/0040_298_40298967_qa_4/instruction.md b/tasks/0040_298_40298967_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f98b0f4270cea064fdea8d66b6ef1ffeba229eb6 --- /dev/null +++ b/tasks/0040_298_40298967_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which number of children corresponds to the lowest average medical charges in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_298_40298967_qa_4/task.toml b/tasks/0040_298_40298967_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..aba3be895c33093b894f3e5147c738677596da66 --- /dev/null +++ b/tasks/0040_298_40298967_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0040_298_40298967_qa_4" +description = "Which number of children corresponds to the lowest average medical charges in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/298/40298967.ipynb_qa_4" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5" +QUESTION = "Which number of children corresponds to the lowest average medical charges 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/0040_627_40627093_qa_1/instruction.md b/tasks/0040_627_40627093_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e163354f164fda5865ccbd9c188b6ad6ea841214 --- /dev/null +++ b/tasks/0040_627_40627093_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 strongest positive correlation with the diabetes outcome (Outcome=1) in the preprocessed 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_627_40627093_qa_1/task.toml b/tasks/0040_627_40627093_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1e44af73affa241e26b0181c1468279be181dbe5 --- /dev/null +++ b/tasks/0040_627_40627093_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0040_627_40627093_qa_1" +description = "Which feature shows the strongest positive correlation with the diabetes outcome (Outcome=1) in the preprocessed dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/627/40627093.ipynb_qa_1" +kaggle_dataset_name = "saurabh00007/diabetescsv" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "saurabh00007__diabetescsv" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "saurabh00007/diabetescsv" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Glucose" +QUESTION = "Which feature shows the strongest positive correlation with the diabetes outcome (Outcome=1) in the preprocessed 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/0040_738_40738491_qa_3/instruction.md b/tasks/0040_738_40738491_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2d42726c634afb7244348ec2b13343098c9e77e9 --- /dev/null +++ b/tasks/0040_738_40738491_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): +- ner_dataset.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique named entity tags are present in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_738_40738491_qa_3/task.toml b/tasks/0040_738_40738491_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..93536baeb8a476db6ff0df55d04df78f39e21832 --- /dev/null +++ b/tasks/0040_738_40738491_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_738_40738491_qa_3" +description = "How many unique named entity tags are present in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/738/40738491.ipynb_qa_3" +kaggle_dataset_name = "abhinavwalia95/entity-annotated-corpus" +gold_answer = "17" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abhinavwalia95__entity-annotated-corpus" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abhinavwalia95/entity-annotated-corpus" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "17" +QUESTION = "How many unique named entity tags are present in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_738_40738491_qa_4/instruction.md b/tasks/0040_738_40738491_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..01c31760f0391a976481e6e59d633591a9f2cd4d --- /dev/null +++ b/tasks/0040_738_40738491_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): +- ner_dataset.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum sentence length in terms of word count before padding? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_738_40738491_qa_4/task.toml b/tasks/0040_738_40738491_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e0a14cad396785df53eba7808f5f437df36b32d1 --- /dev/null +++ b/tasks/0040_738_40738491_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_738_40738491_qa_4" +description = "What is the maximum sentence length in terms of word count before padding?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/738/40738491.ipynb_qa_4" +kaggle_dataset_name = "abhinavwalia95/entity-annotated-corpus" +gold_answer = "104" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abhinavwalia95__entity-annotated-corpus" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abhinavwalia95/entity-annotated-corpus" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "104" +QUESTION = "What is the maximum sentence length in terms of word count before padding?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_015_41015677_qa_4/instruction.md b/tasks/0041_015_41015677_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..57d19aaa6226a104b0a424b7751d12d6e11d76b7 --- /dev/null +++ b/tasks/0041_015_41015677_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which machine learning model achieved the highest test accuracy on the balanced wine quality 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_015_41015677_qa_4/task.toml b/tasks/0041_015_41015677_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f4b025ae7ff734cf0db82eb97d1ba82266d5cac0 --- /dev/null +++ b/tasks/0041_015_41015677_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_015_41015677_qa_4" +description = "Which machine learning model achieved the highest test accuracy on the balanced wine quality dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/015/41015677.ipynb_qa_4" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "Random Forest" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Random Forest" +QUESTION = "Which machine learning model achieved the highest test accuracy on the balanced wine quality dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_020_41020843_qa_4/instruction.md b/tasks/0041_020_41020843_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f59ec0fd7f3bd16e6960038c81e7189f2bf3c85c --- /dev/null +++ b/tasks/0041_020_41020843_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many devices in the dataset have a price_range classification of 3? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_020_41020843_qa_4/task.toml b/tasks/0041_020_41020843_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..668d25507078a37b4ca28aabe48371de04613c61 --- /dev/null +++ b/tasks/0041_020_41020843_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0041_020_41020843_qa_4" +description = "How many devices in the dataset have a price_range classification of 3?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/020/41020843.ipynb_qa_4" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "500" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "500" +QUESTION = "How many devices in the dataset have a price_range classification of 3?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_321_41321221_qa_3/instruction.md b/tasks/0041_321_41321221_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f9e5f2db55943de039885acffa71d09fdbc887e0 --- /dev/null +++ b/tasks/0041_321_41321221_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): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent workclass category in the dataset after removing rows with '?' in the 'occupation' column? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_321_41321221_qa_3/task.toml b/tasks/0041_321_41321221_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e7a2f6a101610a56f2fd603681c5a93bd052cf05 --- /dev/null +++ b/tasks/0041_321_41321221_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0041_321_41321221_qa_3" +description = "What is the most frequent workclass category in the dataset after removing rows with '?' in the 'occupation' column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/321/41321221.ipynb_qa_3" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "Private" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Private" +QUESTION = "What is the most frequent workclass category in the dataset after removing rows with '?' in the 'occupation' column?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_321_41321221_qa_4/instruction.md b/tasks/0041_321_41321221_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..763c2b04d9dc83b105995d9072edc7c346a3af7e --- /dev/null +++ b/tasks/0041_321_41321221_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many rows were removed from the dataset when filtering out rows with '?' in the 'occupation' column? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_321_41321221_qa_4/task.toml b/tasks/0041_321_41321221_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3eb86d87f54b3339c988b764e4a28bfb6beba8ff --- /dev/null +++ b/tasks/0041_321_41321221_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0041_321_41321221_qa_4" +description = "How many rows were removed from the dataset when filtering out rows with '?' in the 'occupation' column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/321/41321221.ipynb_qa_4" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "1843" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1843" +QUESTION = "How many rows were removed from the dataset when filtering out rows with '?' in the 'occupation' column?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_451_41451584_qa_1/instruction.md b/tasks/0041_451_41451584_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dd1ca5e58692817313b942231da21f9511e3d130 --- /dev/null +++ b/tasks/0041_451_41451584_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset shows the strongest positive correlation with the diabetes outcome (1) after missing value 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/0041_451_41451584_qa_1/task.toml b/tasks/0041_451_41451584_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..286aaf9b86bc9eda061020134bc7204ffea407a3 --- /dev/null +++ b/tasks/0041_451_41451584_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0041_451_41451584_qa_1" +description = "Which feature in the dataset shows the strongest positive correlation with the diabetes outcome (1) after missing value imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/451/41451584.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Glucose" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Glucose" +QUESTION = "Which feature in the dataset shows the strongest positive correlation with the diabetes outcome (1) after missing value imputation?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_463_41463553_qa_2/instruction.md b/tasks/0041_463_41463553_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..158fa870b40f544bb683dbe5d99ccff79af90167 --- /dev/null +++ b/tasks/0041_463_41463553_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Life Expectancy Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which country has the highest average population in the dataset based on the pie chart analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_463_41463553_qa_2/task.toml b/tasks/0041_463_41463553_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7dcddfca1b82cdfe338a8df785f8686e76b17067 --- /dev/null +++ b/tasks/0041_463_41463553_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0041_463_41463553_qa_2" +description = "Which country has the highest average population in the dataset based on the pie chart analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/463/41463553.ipynb_qa_2" +kaggle_dataset_name = "kumarajarshi/life-expectancy-who" +gold_answer = "India" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kumarajarshi__life-expectancy-who" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "India" +QUESTION = "Which country has the highest average population in the dataset based on the pie chart 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/0042_372_42372757_qa_1/instruction.md b/tasks/0042_372_42372757_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..956423c01c7696b620b076ea753e8badf59bdfd2 --- /dev/null +++ b/tasks/0042_372_42372757_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the distribution of wine quality labels after segmentation into 'bad' (0) and 'good' (1) in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as comma-separated