diff --git a/tasks/0000_531_531577_qa_1/instruction.md b/tasks/0000_531_531577_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..009d4734d2cdf1bb442fb0f66044aeac59b550b5 --- /dev/null +++ b/tasks/0000_531_531577_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 total stat value observed in the Pokémon 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/0000_531_531577_qa_1/task.toml b/tasks/0000_531_531577_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..94cf9bc8daff306945e4ca44f06f2c9e13ec61d6 --- /dev/null +++ b/tasks/0000_531_531577_qa_1/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_531_531577_qa_1" +description = "What is the highest total stat value observed in the Pokémon dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/531/531577.ipynb_qa_1" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "800" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "780" +QUESTION = "What is the highest total stat value observed in the Pokémon dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0000_621_621324_qa_4/instruction.md b/tasks/0000_621_621324_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..42ec9853a40028696b5260e8da2f2ef0e515e6c2 --- /dev/null +++ b/tasks/0000_621_621324_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): +- database.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common weapon carried by victims with signs of mental illness in fatal shootings? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_621_621324_qa_4/task.toml b/tasks/0000_621_621324_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d92d19b580cba34e55889c3084473a2ef5dcd57c --- /dev/null +++ b/tasks/0000_621_621324_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_621_621324_qa_4" +description = "What is the most common weapon carried by victims with signs of mental illness in fatal shootings?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/621/621324.ipynb_qa_4" +kaggle_dataset_name = "washingtonpost/police-shootings" +gold_answer = "gun" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "washingtonpost__police-shootings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "washingtonpost/police-shootings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "gun" +QUESTION = "What is the most common weapon carried by victims with signs of mental illness in fatal shootings?" +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/0000_806_806826_qa_5/instruction.md b/tasks/0000_806_806826_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..582a9c516f40de06f2712b432bd1816ed3d773f4 --- /dev/null +++ b/tasks/0000_806_806826_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- archive.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the distribution of temperature deviations between February and March approximately normal based on the kernel density estimate and observed frequency counts? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_806_806826_qa_5/task.toml b/tasks/0000_806_806826_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3ac4dbfce267a355b6972370a92f996e33b8d2b1 --- /dev/null +++ b/tasks/0000_806_806826_qa_5/task.toml @@ -0,0 +1,56 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_806_806826_qa_5" +description = "Is the distribution of temperature deviations between February and March approximately normal based on the kernel density estimate and observed frequency counts?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/806/806826.ipynb_qa_5" +kaggle_dataset_name = "groundhogclub/groundhog-day" +gold_answer = "Yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "groundhogclub__groundhog-day" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "groundhogclub/groundhog-day" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Yes" +QUESTION = "Is the distribution of temperature deviations between February and March approximately normal based on the kernel density estimate and observed frequency counts?" +REWARD_MODE = "exact_bool" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0000_965_965367_qa_1/instruction.md b/tasks/0000_965_965367_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..aafb08921b0d579ace15f57df1caf354fedae726 --- /dev/null +++ b/tasks/0000_965_965367_qa_1/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- salary.csv +- team.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many World Series winners since 1985 had the highest payroll rank (rank 1)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0000_965_965367_qa_1/task.toml b/tasks/0000_965_965367_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..440b6463c9d1ef0b9fadc2d8df892814701336c0 --- /dev/null +++ b/tasks/0000_965_965367_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_965_965367_qa_1" +description = "How many World Series winners since 1985 had the highest payroll rank (rank 1)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/965/965367.ipynb_qa_1" +kaggle_dataset_name = "seanlahman/the-history-of-baseball" +gold_answer = "5" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "seanlahman__the-history-of-baseball" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "seanlahman/the-history-of-baseball" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5" +QUESTION = "How many World Series winners since 1985 had the highest payroll rank (rank 1)?" +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_068_1068916_qa_1/instruction.md b/tasks/0001_068_1068916_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..adb795ddffdb8a20c347c7045f4d4bcc100e714c --- /dev/null +++ b/tasks/0001_068_1068916_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average spam score across all entries in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_068_1068916_qa_1/task.toml b/tasks/0001_068_1068916_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bc1d604f781a40580f2a797f8d6c2b97085c067d --- /dev/null +++ b/tasks/0001_068_1068916_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_068_1068916_qa_1" +description = "What is the average spam score across all entries in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/068/1068916.ipynb_qa_1" +kaggle_dataset_name = "mrisdal/fake-news" +gold_answer = "0.026" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mrisdal__fake-news" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mrisdal/fake-news" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.026" +QUESTION = "What is the average spam score across all entries in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_085_1085629_qa_2/instruction.md b/tasks/0001_085_1085629_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9ab272a1d466d7d8f1c579ff586e555a5483cdd9 --- /dev/null +++ b/tasks/0001_085_1085629_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 are the top three features according to the feature importance ranking provided by the Extra Trees Classifier? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_085_1085629_qa_2/task.toml b/tasks/0001_085_1085629_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..917a7eefd0bda3ec86762555dd9b49c702b7fa0f --- /dev/null +++ b/tasks/0001_085_1085629_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_085_1085629_qa_2" +description = "What are the top three features according to the feature importance ranking provided by the Extra Trees Classifier?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/085/1085629.ipynb_qa_2" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "fnlwgt, age, hours.per.week" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "fnlwgt, age, hours.per.week" +QUESTION = "What are the top three features according to the feature importance ranking provided by the Extra Trees Classifier?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_250_1250662_qa_3/instruction.md b/tasks/0001_250_1250662_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7e1bd8c85cbe1bf0d36b7d9ba0085613a76c194a --- /dev/null +++ b/tasks/0001_250_1250662_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): +- survey_results_public.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average ideal workday start time (in 24-hour format) for R users 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_250_1250662_qa_3/task.toml b/tasks/0001_250_1250662_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6f94291b3b7fdb1cd50aebd95096c0387e01877b --- /dev/null +++ b/tasks/0001_250_1250662_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_250_1250662_qa_3" +description = "What is the average ideal workday start time (in 24-hour format) for R users in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/250/1250662.ipynb_qa_3" +kaggle_dataset_name = "stackoverflow/so-survey-2017" +gold_answer = "9.293624" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "stackoverflow__so-survey-2017" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "stackoverflow/so-survey-2017" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "9.293624" +QUESTION = "What is the average ideal workday start time (as a decimal number in 24-hour format, e.g. 9.5 means 9:30 AM) for R users in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.01" +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_240_2240465_qa_4/instruction.md b/tasks/0002_240_2240465_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ca34c7a946f054def4ad02ff23409fb70902f884 --- /dev/null +++ b/tasks/0002_240_2240465_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the 90th percentile of USD pledged amount for technology category projects? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0002_240_2240465_qa_4/task.toml b/tasks/0002_240_2240465_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c752948267cbb7387d02c0f0ad344f9ab0ebe624 --- /dev/null +++ b/tasks/0002_240_2240465_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0002_240_2240465_qa_4" +description = "What is the 90th percentile of USD pledged amount for technology category projects?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/240/2240465.ipynb_qa_4" +kaggle_dataset_name = "kemical/kickstarter-projects" +gold_answer = "21223.50" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kemical__kickstarter-projects" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kemical/kickstarter-projects" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "21223.50" +QUESTION = "What is the 90th percentile of USD pledged amount for technology category projects?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0011_222_11222401_qa_5/instruction.md b/tasks/0011_222_11222401_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d4049c2b63e21e7577eb1ec8845de0fa0f2b78ce --- /dev/null +++ b/tasks/0011_222_11222401_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): +- Reviews.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the top negative word contributing to negative sentiment predictions in the model? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0011_222_11222401_qa_5/task.toml b/tasks/0011_222_11222401_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d76aaca828220478202cbb41ce3a80775e3d84c7 --- /dev/null +++ b/tasks/0011_222_11222401_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0011_222_11222401_qa_5" +description = "What is the top negative word contributing to negative sentiment predictions in the model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/222/11222401.ipynb_qa_5" +kaggle_dataset_name = "snap/amazon-fine-food-reviews" +gold_answer = "disappointing" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "snap__amazon-fine-food-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "snap/amazon-fine-food-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "worst" +QUESTION = "What is the top negative word contributing to negative sentiment predictions in the model?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0016_558_16558367_qa_1/instruction.md b/tasks/0016_558_16558367_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a1c76f262a4871bc28d44ea6b8b8c785c47d681d --- /dev/null +++ b/tasks/0016_558_16558367_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which user has the highest total positive sentiment score according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0016_558_16558367_qa_1/task.toml b/tasks/0016_558_16558367_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e28f084d12600c2ea1113808ca1f7063c4ee5b16 --- /dev/null +++ b/tasks/0016_558_16558367_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0016_558_16558367_qa_1" +description = "Which user has the highest total positive sentiment score according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/558/16558367.ipynb_qa_1" +kaggle_dataset_name = "arathee2/demonetization-in-india-twitter-data" +gold_answer = "mituamin" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "arathee2__demonetization-in-india-twitter-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arathee2/demonetization-in-india-twitter-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "mituamin" +QUESTION = "Which user has the highest total positive sentiment score according to the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0016_734_16734421_qa_3/instruction.md b/tasks/0016_734_16734421_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..479358e4651af115c04bb0a1ff81e7eadb09db1f --- /dev/null +++ b/tasks/0016_734_16734421_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which student performance class (H/M/L) achieved the highest F1-score in the Random Forest model evaluation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0016_734_16734421_qa_3/task.toml b/tasks/0016_734_16734421_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a033b3f092d3f305ce5ad64850231a355d6a067b --- /dev/null +++ b/tasks/0016_734_16734421_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0016_734_16734421_qa_3" +description = "Which student performance class (H/M/L) achieved the highest F1-score in the Random Forest model evaluation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0016/734/16734421.ipynb_qa_3" +kaggle_dataset_name = "aljarah/xAPI-Edu-Data" +gold_answer = "L" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "aljarah__xAPI-Edu-Data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "aljarah/xAPI-Edu-Data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "L" +QUESTION = "Which student performance class (H/M/L) achieved the highest F1-score in the Random Forest model evaluation?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0017_740_17740333_qa_1/instruction.md b/tasks/0017_740_17740333_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4b5eac7d8af786ea923dbfcd1cd282045b634355 --- /dev/null +++ b/tasks/0017_740_17740333_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between average monthly hours worked and time spent at the company in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0017_740_17740333_qa_1/task.toml b/tasks/0017_740_17740333_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5a9cac588b99f3a31c513487594bea9580dcf1b7 --- /dev/null +++ b/tasks/0017_740_17740333_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0017_740_17740333_qa_1" +description = "What is the correlation coefficient between average monthly hours worked and time spent at the company in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/740/17740333.ipynb_qa_1" +kaggle_dataset_name = "jiangzuo/hr-comma-sep" +gold_answer = "0.12775491036185835" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "jiangzuo__hr-comma-sep" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "jiangzuo/hr-comma-sep" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.12775491036185835" +QUESTION = "What is the correlation coefficient between average monthly hours worked and time spent at the company in the dataset?" +REWARD_MODE = "flexible" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0020_991_20991108_qa_5/instruction.md b/tasks/0020_991_20991108_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b1a1c5c7d6772bfb5815742b7671dbe7c9d58a65 --- /dev/null +++ b/tasks/0020_991_20991108_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- sensor_readings_24.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of test samples evaluated in the MLP model's confusion matrix output? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0020_991_20991108_qa_5/task.toml b/tasks/0020_991_20991108_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bc4da00a5a606b04eab1a6ff33764da673fb7e00 --- /dev/null +++ b/tasks/0020_991_20991108_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0020_991_20991108_qa_5" +description = "What is the total number of test samples evaluated in the MLP model's confusion matrix output?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/991/20991108.ipynb_qa_5" +kaggle_dataset_name = "uciml/wall-following-robot" +gold_answer = "1637 samples" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__wall-following-robot" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/wall-following-robot" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1637 samples" +QUESTION = "What is the total number of test samples evaluated in the MLP model's confusion matrix output? (Use a 70/30 train/test split with test_size=0.3)" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0021_751_21751462_qa_4/instruction.md b/tasks/0021_751_21751462_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0606f7c908bbd7303b199b8d9818cbef4c9271b9 --- /dev/null +++ b/tasks/0021_751_21751462_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): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many duplicate property records were identified and removed based on the unique combination of location, date, and property characteristics? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0021_751_21751462_qa_4/task.toml b/tasks/0021_751_21751462_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..456621a507da519674ae18e412215557362d1c14 --- /dev/null +++ b/tasks/0021_751_21751462_qa_4/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0021_751_21751462_qa_4" +description = "How many duplicate property records were identified and removed based on the unique combination of location, date, and property characteristics?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/751/21751462.ipynb_qa_4" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "2" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "How many duplicate property records were identified and removed based on the unique combination of location, date, and property characteristics? (Count all rows that are part of any duplicate group, i.e., use keep=False when identifying duplicates.)" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0021_803_21803688_qa_1/instruction.md b/tasks/0021_803_21803688_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ad68dcd6c05998041daeee7e8372bf588c4e5f4c --- /dev/null +++ b/tasks/0021_803_21803688_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which two features are identified as the most important predictors of diamond price according to the RandomForestRegressor model based on feature importance scores? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0021_803_21803688_qa_1/task.toml b/tasks/0021_803_21803688_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..452869b6feddc9cca8324fb91df50231d60974ac --- /dev/null +++ b/tasks/0021_803_21803688_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0021_803_21803688_qa_1" +description = "Which two features are identified as the most important predictors of diamond price according to the RandomForestRegressor model based on feature importance scores?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/803/21803688.ipynb_qa_1" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "carat and y" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "carat and y" +QUESTION = "Which two features are identified as the most important predictors of diamond price according to the RandomForestRegressor model based on feature importance scores?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0023_721_23721314_qa_1/instruction.md b/tasks/0023_721_23721314_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..44edbbb1bb775053654e87aa4df851087596e1b7 --- /dev/null +++ b/tasks/0023_721_23721314_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest single-season passing yardage achieved by a player in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_721_23721314_qa_1/task.toml b/tasks/0023_721_23721314_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c5c8d4e6469dffcccd48344d76f661f1b5c0785c --- /dev/null +++ b/tasks/0023_721_23721314_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0023_721_23721314_qa_1" +description = "What is the highest single-season passing yardage achieved by a player in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/721/23721314.ipynb_qa_1" +kaggle_dataset_name = "jerrinv/nfl-offense-cleaned-2017to2007" +gold_answer = "5477" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "jerrinv__nfl-offense-cleaned-2017to2007" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "jerrinv/nfl-offense-cleaned-2017to2007" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5477" +QUESTION = "What is the highest single-season passing yardage achieved by a player 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/0023_846_23846255_qa_1/instruction.md b/tasks/0023_846_23846255_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..16051bda1659f8a4b4a3bbf73171d57bbf1d5cd9 --- /dev/null +++ b/tasks/0023_846_23846255_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the absolute difference between the maximum purchase amount and the 75th percentile purchase amount in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_908_23908999_qa_2/task.toml b/tasks/0023_908_23908999_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5d6d5b11c0616a9b74069255d60d7e6bb3cb7dc3 --- /dev/null +++ b/tasks/0023_908_23908999_qa_2/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0023_908_23908999_qa_2" +description = "What is the most frequently used opening move in the dataset, and how many times does it appear?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/908/23908999.ipynb_qa_2" +kaggle_dataset_name = "datasnaek/chess" +gold_answer = "e4 with 12598 occurrences" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "datasnaek__chess" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datasnaek/chess" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "e4 with 12598 occurrences" +QUESTION = "What is the most frequently used opening move in the dataset, and how many times does it appear?" +REWARD_MODE = "exact_short" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0024_991_24991983_qa_2/instruction.md b/tasks/0024_991_24991983_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8c819336565747377b116d670aef1572000a12af --- /dev/null +++ b/tasks/0024_991_24991983_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest correlation coefficient between any two features in the dataset according to the heatmap visualization? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0024_991_24991983_qa_2/task.toml b/tasks/0024_991_24991983_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3c58ac91979839b109da1233a8b045d14bdcb078 --- /dev/null +++ b/tasks/0024_991_24991983_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0024_991_24991983_qa_2" +description = "What is the highest correlation coefficient between any two features in the dataset according to the heatmap visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/991/24991983.ipynb_qa_2" +kaggle_dataset_name = "yuqing01/breast-cancer" +gold_answer = "0.98" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "yuqing01__breast-cancer" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "yuqing01/breast-cancer" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.98" +QUESTION = "What is the highest correlation coefficient between any two features in the dataset according to the heatmap visualization?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0026_141_26141545_qa_4/instruction.md b/tasks/0026_141_26141545_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2ff69f072592cdb3ed82434fb9b4c9eff43bd81f --- /dev/null +++ b/tasks/0026_141_26141545_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): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which combination of variables demonstrated the strongest predictive power for survival outcomes in the bivariate 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_141_26141545_qa_4/task.toml b/tasks/0026_141_26141545_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9906f78669e63dcce7ab6d4f475331066b137187 --- /dev/null +++ b/tasks/0026_141_26141545_qa_4/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0026_141_26141545_qa_4" +description = "Which combination of variables demonstrated the strongest predictive power for survival outcomes in the bivariate analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/141/26141545.ipynb_qa_4" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "Age and No.of.AxillaryNodes" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 4 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "Age and No.of.AxillaryNodes" +QUESTION = "Which combination of variables demonstrated the strongest predictive power for survival outcomes in the bivariate analysis? (Consider KDE/distribution-based separation between survival classes, not logistic regression AUC. The answer should be a pair of the three feature variables: Age, Year of operation, and No.of.AxillaryNodes.)" +REWARD_MODE = "flexible" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0029_908_29908654_qa_2/instruction.md b/tasks/0029_908_29908654_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fc2d9f7d343f8cb6c4f1a87f996888a312cfb4d7 --- /dev/null +++ b/tasks/0029_908_29908654_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: +Among the selected samples (43, 12, 39), which one has the highest Grocery spending value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0029_908_29908654_qa_2/task.toml b/tasks/0029_908_29908654_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4579f082d5b3bc655005c4aafd0998ab13897a05 --- /dev/null +++ b/tasks/0029_908_29908654_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0029_908_29908654_qa_2" +description = "Among the selected samples (43, 12, 39), which one has the highest Grocery spending value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0029/908/29908654.ipynb_qa_2" +kaggle_dataset_name = "nguyen17/uci-wholesale-customers-data" +gold_answer = "43" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "nguyen17__uci-wholesale-customers-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "nguyen17/uci-wholesale-customers-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "43" +QUESTION = "Among the selected samples (43, 12, 39), which one has the highest Grocery spending value?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_680_32680563_qa_2/instruction.md b/tasks/0032_680_32680563_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7034601c0340e306e6be5f3bed21526d173e8b2e --- /dev/null +++ b/tasks/0032_680_32680563_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of training samples for the author with the highest representation in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0032_680_32680563_qa_2/task.toml b/tasks/0032_680_32680563_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a51917bfa982b30934451edc1e3e645794d06a2c --- /dev/null +++ b/tasks/0032_680_32680563_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0032_680_32680563_qa_2" +description = "What is the total number of training samples for the author with the highest representation in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/680/32680563.ipynb_qa_2" +kaggle_dataset_name = "lyuyanhan/spookyauthordata" +gold_answer = "7900" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "lyuyanhan__spookyauthordata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "lyuyanhan/spookyauthordata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7900" +QUESTION = "What is the total number of training samples for the author with the highest representation in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_916_34916115_qa_2/instruction.md b/tasks/0034_916_34916115_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..dcd06d9e9f83aa60e9e93cb995249a75b070df7f --- /dev/null +++ b/tasks/0034_916_34916115_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which country produces wines with the highest average price 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/0034_916_34916115_qa_2/task.toml b/tasks/0034_916_34916115_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ec7c56a9a087d73cdd1ae4d8c430416c5f800fe1 --- /dev/null +++ b/tasks/0034_916_34916115_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0034_916_34916115_qa_2" +description = "Which country produces wines with the highest average price according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/916/34916115.ipynb_qa_2" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "Switzerland" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Switzerland" +QUESTION = "Which country produces wines with the highest average price according to the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_835_35835284_qa_2/instruction.md b/tasks/0035_835_35835284_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a2e62f1b586091e14be570cc2a4e0bcf737ae3ef --- /dev/null +++ b/tasks/0035_835_35835284_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): +- SolarPrediction.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the hour of the day with the highest average solar radiation 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/0035_835_35835284_qa_2/task.toml b/tasks/0035_835_35835284_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6a00960516ddd725fcb22cb2a83f2ad9bb8e531a --- /dev/null +++ b/tasks/0035_835_35835284_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0035_835_35835284_qa_2" +description = "What is the hour of the day with the highest average solar radiation based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/835/35835284.ipynb_qa_2" +kaggle_dataset_name = "dronio/SolarEnergy" +gold_answer = "12" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "dronio__SolarEnergy" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dronio/SolarEnergy" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "12" +QUESTION = "What is the hour of the day with the highest average solar radiation 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/0036_230_36230590_qa_1/instruction.md b/tasks/0036_230_36230590_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3ffb51afa432a4afa9e2277fe0cafa46db84b998 --- /dev/null +++ b/tasks/0036_230_36230590_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the third most used female name in the year 2002? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0036_230_36230590_qa_1/task.toml b/tasks/0036_230_36230590_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b63970f24ef3d319d825182c9e7007d88ff9986f --- /dev/null +++ b/tasks/0036_230_36230590_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0036_230_36230590_qa_1" +description = "What is the third most used female name in the year 2002?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/230/36230590.ipynb_qa_1" +kaggle_dataset_name = "kaggle/us-baby-names" +gold_answer = "Hannah" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kaggle__us-baby-names" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kaggle/us-baby-names" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Hannah" +QUESTION = "What is the third most used female name in the year 2002?" +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_236_37236169_qa_4/instruction.md b/tasks/0037_236_37236169_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7898753fa6b0ed79641bfa94a3645ff5c7e6649f --- /dev/null +++ b/tasks/0037_236_37236169_qa_4/instruction.md @@ -0,0 +1,19 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- PercentagePeopleBelowPovertyLevel.csv +- PercentOver25CompletedHighSchool.csv +- MedianHouseholdIncome2015.csv +- PoliceKillingsUS.csv +- ShareRaceByCity.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of unique names and surnames combined in the police killings dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0037_236_37236169_qa_4/task.toml b/tasks/0037_236_37236169_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bfb0fa3363355524338d0c678242e0f26f4ce1fa --- /dev/null +++ b/tasks/0037_236_37236169_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0037_236_37236169_qa_4" +description = "What is the total number of unique names and surnames combined in the police killings dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/236/37236169.ipynb_qa_4" +kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us" +gold_answer = "4972" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kwullum__fatal-police-shootings-in-the-us" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2646" +QUESTION = "What is the total number of unique names and surnames combined in the police killings dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0037_728_37728227_qa_2/instruction.md b/tasks/0037_728_37728227_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..017e41eeb398da23babefa72bcdc42ec1bae3d8c --- /dev/null +++ b/tasks/0037_728_37728227_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 ratio of non-exoplanet-labeled samples (class 1) to exoplanet-labeled samples (class 2) in the training dataset based on the confusion matrix output? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0037_728_37728227_qa_2/task.toml b/tasks/0037_728_37728227_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..89bcd6fc3cac024bd819e4611c8f3424fc73bd7a --- /dev/null +++ b/tasks/0037_728_37728227_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0037_728_37728227_qa_2" +description = "What is the ratio of non-exoplanet-labeled samples (class 1) to exoplanet-labeled samples (class 2) in the training dataset based on the confusion matrix output?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/728/37728227.ipynb_qa_2" +kaggle_dataset_name = "keplersmachines/kepler-labelled-time-series-data" +gold_answer = "136.2" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "keplersmachines__kepler-labelled-time-series-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "keplersmachines/kepler-labelled-time-series-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "136.2" +QUESTION = "What is the ratio of non-exoplanet-labeled samples (class 1) to exoplanet-labeled samples (class 2) in the training dataset based on the confusion matrix output?" +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_560_39560761_qa_1/instruction.md b/tasks/0039_560_39560761_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c80b55ce68d04be7f9c2af54d332f6cd0aaae6f4 --- /dev/null +++ b/tasks/0039_560_39560761_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the proportion of diabetic patients (Outcome=1) in the PIMA Indians diabetes 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_560_39560761_qa_1/task.toml b/tasks/0039_560_39560761_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..578e52c9b71d7494ca338a5db5b8999dcedbe58d --- /dev/null +++ b/tasks/0039_560_39560761_qa_1/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0039_560_39560761_qa_1" +description = "What is the proportion of diabetic patients (Outcome=1) in the PIMA Indians diabetes dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/560/39560761.ipynb_qa_1" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "34.9%" +reward_mode_initial = "flexible" +package_tier = 2 +difficulty_level = 1 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "34.9%" +QUESTION = "What is the proportion of diabetic patients (Outcome=1) in the PIMA Indians diabetes dataset? Express as a percentage rounded to one decimal place." +REWARD_MODE = "flexible" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0041_703_41703265_qa_4/instruction.md b/tasks/0041_703_41703265_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e9778ad1b2270aeba31a9c34971e712f9b2cd1a0 --- /dev/null +++ b/tasks/0041_703_41703265_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference in macro-averaged F1-score between the top-performing and bottom-performing models? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_703_41703265_qa_4/task.toml b/tasks/0041_703_41703265_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7c00b198b07e971a22d3a1dc4d58cad02b47f0ac --- /dev/null +++ b/tasks/0041_703_41703265_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0041_703_41703265_qa_4" +description = "What is the difference in macro-averaged F1-score between the top-performing and bottom-performing models?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/703/41703265.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.00" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.00" +QUESTION = "What is the difference in macro-averaged F1-score between the top-performing and bottom-performing models?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_818_41818748_qa_5/instruction.md b/tasks/0041_818_41818748_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ffb1fb9e67e3160046ba5bb316558990daf96c2a --- /dev/null +++ b/tasks/0041_818_41818748_qa_5/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Train.csv +- Test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of total sales contributed by Supermarket Type1 outlets compared to other outlet types? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_818_41818748_qa_5/task.toml b/tasks/0041_818_41818748_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7f2a92f4ad82877653254f2621a4791b2e111e5e --- /dev/null +++ b/tasks/0041_818_41818748_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0041_818_41818748_qa_5" +description = "What is the percentage of total sales contributed by Supermarket Type1 outlets compared to other outlet types?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/818/41818748.ipynb_qa_5" +kaggle_dataset_name = "devashish0507/big-mart-sales-prediction" +gold_answer = "48.2%" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "devashish0507__big-mart-sales-prediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "devashish0507/big-mart-sales-prediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "69.48%" +QUESTION = "What is the percentage of total sales contributed by Supermarket Type1 outlets compared to other outlet types?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0045_874_45874370_qa_5/instruction.md b/tasks/0045_874_45874370_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0147c6b1ac24ff2952d309d99964b991f227eb51 --- /dev/null +++ b/tasks/0045_874_45874370_qa_5/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- test.csv +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of mobile phones in price range 0 are 3G compatible according to the pie chart visualization? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0045_874_45874370_qa_5/task.toml b/tasks/0045_874_45874370_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1e999ca702bf2bc9cad582e227d731069d298bea --- /dev/null +++ b/tasks/0045_874_45874370_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0045_874_45874370_qa_5" +description = "What percentage of mobile phones in price range 0 are 3G compatible according to the pie chart visualization?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0045/874/45874370.ipynb_qa_5" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "98.5%" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "74.6%" +QUESTION = "What percentage of mobile phones in price range 0 are 3G compatible according to the pie chart visualization?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0046_788_46788472_qa_4/instruction.md b/tasks/0046_788_46788472_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7768b6cb3b13b10017052e37d00b313ae3834c8a --- /dev/null +++ b/tasks/0046_788_46788472_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average global sales value (Global_Sales) per 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/0046_788_46788472_qa_4/task.toml b/tasks/0046_788_46788472_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..027e4b5b74ff3146cdc1d2d0ed216fb9f3d50e75 --- /dev/null +++ b/tasks/0046_788_46788472_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0046_788_46788472_qa_4" +description = "What is the average global sales value (Global_Sales) per game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0046/788/46788472.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "0.54" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.54" +QUESTION = "What is the average global sales value (Global_Sales) per 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/0046_955_46955725_qa_4/instruction.md b/tasks/0046_955_46955725_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..00b2713745195fc6604c362d7ac8713fb3b8ee1f --- /dev/null +++ b/tasks/0046_955_46955725_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many games in the dataset resulted in team 2 winning under the condition that all six early game advantages were secured? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0046_955_46955725_qa_4/task.toml b/tasks/0046_955_46955725_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..23c06a7c8fff7f341e606b3acda95c9c41fb6da8 --- /dev/null +++ b/tasks/0046_955_46955725_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0046_955_46955725_qa_4" +description = "How many games in the dataset resulted in team 2 winning under the condition that all six early game advantages were secured?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0046/955/46955725.ipynb_qa_4" +kaggle_dataset_name = "datasnaek/league-of-legends" +gold_answer = "1648" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "datasnaek__league-of-legends" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datasnaek/league-of-legends" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1648" +QUESTION = "How many games in the dataset resulted in team 2 winning under the condition that all six early game advantages were secured?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0047_417_47417997_qa_3/instruction.md b/tasks/0047_417_47417997_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d6841846e5b43164fc9205a42e1baecbeca0d05b --- /dev/null +++ b/tasks/0047_417_47417997_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +For class 1 (Outcome=1) in the validation set, what was the F1-score achieved by the model? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0047_417_47417997_qa_3/task.toml b/tasks/0047_417_47417997_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1793d5b17aa1cc4b8ed424ae26c7421d0650f84b --- /dev/null +++ b/tasks/0047_417_47417997_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0047_417_47417997_qa_3" +description = "For class 1 (Outcome=1) in the validation set, what was the F1-score achieved by the model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0047/417/47417997.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "0.651" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.651" +QUESTION = "For class 1 (Outcome=1) in the validation set, what was the F1-score achieved by the model?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0048_966_48966571_qa_3/instruction.md b/tasks/0048_966_48966571_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..27829114d39b95750b61b215f31e49c28aca21e0 --- /dev/null +++ b/tasks/0048_966_48966571_qa_3/instruction.md @@ -0,0 +1,19 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- movies_metadata.csv +- links_small.csv +- credits.csv +- keywords.csv +- ratings_small.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Using content-based recommendations, which movie is most similar to "The Dark Knight" based on TF-IDF description analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0048_966_48966571_qa_3/task.toml b/tasks/0048_966_48966571_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..65d81229e23cd1de1f3eccf66475cfec761f60a6 --- /dev/null +++ b/tasks/0048_966_48966571_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0048_966_48966571_qa_3" +description = "Using content-based recommendations, which movie is most similar to \"The Dark Knight\" based on TF-IDF description analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0048/966/48966571.ipynb_qa_3" +kaggle_dataset_name = "rounakbanik/the-movies-dataset" +gold_answer = "The Dark Knight Rises" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rounakbanik__the-movies-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rounakbanik/the-movies-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "The Dark Knight Rises" +QUESTION = "Using content-based recommendations, which movie is most similar to \"The Dark Knight\" based on TF-IDF description analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0051_653_51653330_qa_5/instruction.md b/tasks/0051_653_51653330_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e18ccef8252fca0365bc6c6c059bfec8f0037392 --- /dev/null +++ b/tasks/0051_653_51653330_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Indian state has the highest total value of property stolen in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0051_653_51653330_qa_5/task.toml b/tasks/0051_653_51653330_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b433ae1fb497a9698d51ca037d9668f2b08582f7 --- /dev/null +++ b/tasks/0051_653_51653330_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0051_653_51653330_qa_5" +description = "Which Indian state has the highest total value of property stolen in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0051/653/51653330.ipynb_qa_5" +kaggle_dataset_name = "rajanand/crime-in-india" +gold_answer = "Maharashtra" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rajanand__crime-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/crime-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Maharashtra" +QUESTION = "Which Indian state has the highest total value of property stolen in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0054_256_54256432_qa_2/instruction.md b/tasks/0054_256_54256432_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..551a7e94eaa2fd19d06ad773b4c071ea5b8fb8ab --- /dev/null +++ b/tasks/0054_256_54256432_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): +- seattleWeather_1948-2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest accuracy achieved by the Naïve Bayes classifier using any combination of features (PRCP, TMAX, TMIN) for rain prediction? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0060_427_60427905_qa_2/instruction.md b/tasks/0060_427_60427905_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ebcf515d549c4499f69c71d69d89c604de2636d6 --- /dev/null +++ b/tasks/0060_427_60427905_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- indian_liver_patient.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest importance in predicting liver disease according to the Random Forest model? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0060_427_60427905_qa_2/task.toml b/tasks/0060_427_60427905_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1ee2e7519e1f0a4475e555a3ddb2eb9fffeddbbf --- /dev/null +++ b/tasks/0060_427_60427905_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0060_427_60427905_qa_2" +description = "Which feature has the highest importance in predicting liver disease according to the Random Forest model?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0060/427/60427905.ipynb_qa_2" +kaggle_dataset_name = "uciml/indian-liver-patient-records" +gold_answer = "Total_Bilirubin" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__indian-liver-patient-records" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/indian-liver-patient-records" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Alkaline_Phosphotase" +QUESTION = "Which feature has the highest importance in predicting liver disease according to the Random Forest model?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0064_551_64551026_qa_4/instruction.md b/tasks/0064_551_64551026_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4f2e96c6010fbc51a68280ae81a1a5c38f9de38b --- /dev/null +++ b/tasks/0064_551_64551026_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many patients in the dataset have a positive diabetes diagnosis (Outcome = 1)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0064_551_64551026_qa_4/task.toml b/tasks/0064_551_64551026_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8a622fd81fe7f23e5f9adaa1b966cc33b2c08973 --- /dev/null +++ b/tasks/0064_551_64551026_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0064_551_64551026_qa_4" +description = "How many patients in the dataset have a positive diabetes diagnosis (Outcome = 1)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0064/551/64551026.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "268" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__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 = "How many patients in the dataset have a positive diabetes diagnosis (Outcome = 1)?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0066_429_66429634_qa_5/instruction.md b/tasks/0066_429_66429634_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..82c688d834b4380e3ed59d09a5cea1ff50fff1ec --- /dev/null +++ b/tasks/0066_429_66429634_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which preprocessing step reduced the variance of 'free sulfur dioxide' from 109.414884 to 0.469624? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0066_429_66429634_qa_5/task.toml b/tasks/0066_429_66429634_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..308171d40b01a3dd2b01cf26204ab2f92d4b3c12 --- /dev/null +++ b/tasks/0066_429_66429634_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0066_429_66429634_qa_5" +description = "Which preprocessing step reduced the variance of 'free sulfur dioxide' from 109.414884 to 0.469624?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/429/66429634.ipynb_qa_5" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "Log transformation" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Log transformation" +QUESTION = "Which preprocessing step reduced the variance of 'free sulfur dioxide' from 109.414884 to 0.469624?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0067_489_67489322_qa_4/instruction.md b/tasks/0067_489_67489322_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..56d986904fac823d03a68894f35443aba172d292 --- /dev/null +++ b/tasks/0067_489_67489322_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique education categories are present in the dataset after data cleaning? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0067_489_67489322_qa_4/task.toml b/tasks/0067_489_67489322_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..68b78fa9be38498fe5d77d6ba49d238be64ae6fb --- /dev/null +++ b/tasks/0067_489_67489322_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0067_489_67489322_qa_4" +description = "How many unique education categories are present in the dataset after data cleaning?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/489/67489322.ipynb_qa_4" +kaggle_dataset_name = "wenruliu/adult-income-dataset" +gold_answer = "16" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "wenruliu__adult-income-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wenruliu/adult-income-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "16" +QUESTION = "How many unique education categories are present in the dataset after data cleaning?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0067_933_67933757_qa_2/instruction.md b/tasks/0067_933_67933757_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..323788df0bb234fcf8ff6e013814712487ba5b4f --- /dev/null +++ b/tasks/0067_933_67933757_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which continent has the highest total sales, and what is the total sales amount in millions? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0067_933_67933757_qa_2/task.toml b/tasks/0067_933_67933757_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e375ed310d66c2b7a247ace7e3aa45035f6294c4 --- /dev/null +++ b/tasks/0067_933_67933757_qa_2/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0067_933_67933757_qa_2" +description = "Which continent has the highest total sales, and what is the total sales amount in millions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0067/933/67933757.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "North America (NA), 4327.65" +reward_mode_initial = "flexible" +package_tier = 0 +difficulty_level = 2 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "North America (NA), 4392.95" +QUESTION = "Which continent has the highest total sales, and what is the total sales amount in millions?" +REWARD_MODE = "flexible" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0074_276_74276642_qa_3/instruction.md b/tasks/0074_276_74276642_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..34f4ac482d88dc42e29594578523f1c644182080 --- /dev/null +++ b/tasks/0074_276_74276642_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the minimum age of employees who left the company (Attrition=Yes)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0074_276_74276642_qa_3/task.toml b/tasks/0074_276_74276642_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dde60157328b6bc102bb34ed38538e375b8bc45d --- /dev/null +++ b/tasks/0074_276_74276642_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0074_276_74276642_qa_3" +description = "What is the minimum age of employees who left the company (Attrition=Yes)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/276/74276642.ipynb_qa_3" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "18" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "18" +QUESTION = "What is the minimum age of employees who left the company (Attrition=Yes)?" +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/0078_655_78655226_qa_5/instruction.md b/tasks/0078_655_78655226_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..56762274fb481904d69968fe5a6dcaea61d57ab8 --- /dev/null +++ b/tasks/0078_655_78655226_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correct ordering of features by their absolute correlation with MEDV, from highest to lowest, as shown in the 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/0078_655_78655226_qa_5/task.toml b/tasks/0078_655_78655226_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4ef1676236fc36118d3f13608a2b879bde92b610 --- /dev/null +++ b/tasks/0078_655_78655226_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0078_655_78655226_qa_5" +description = "What is the correct ordering of features by their absolute correlation with MEDV, from highest to lowest, as shown in the analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0078/655/78655226.ipynb_qa_5" +kaggle_dataset_name = "schirmerchad/bostonhoustingmlnd" +gold_answer = "LSTAT, RM, PTRATIO" +reward_mode_initial = "list_csv" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "schirmerchad__bostonhoustingmlnd" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "schirmerchad/bostonhoustingmlnd" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "LSTAT, RM, PTRATIO" +QUESTION = "What is the correct ordering of features by their absolute correlation with MEDV, from highest to lowest, as shown in the analysis?" +REWARD_MODE = "list_csv" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0085_952_85952796_qa_2/instruction.md b/tasks/0085_952_85952796_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2531b3be34b8ef31d34ec0ad7398d83c48ceb30a --- /dev/null +++ b/tasks/0085_952_85952796_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): +- 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 10% trimmed mean of User_Score after excluding the top and bottom 10% of 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/0085_952_85952796_qa_2/task.toml b/tasks/0085_952_85952796_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9764b63ff77f23aeb5b62a4b247faa4665e28e04 --- /dev/null +++ b/tasks/0085_952_85952796_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0085_952_85952796_qa_2" +description = "What is the 10% trimmed mean of User_Score after excluding the top and bottom 10% of values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0085/952/85952796.ipynb_qa_2" +kaggle_dataset_name = "rush4ratio/video-game-sales-with-ratings" +gold_answer = "7.314756258234518" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "7.314756258234518" +QUESTION = "What is the 10% trimmed mean of User_Score after excluding the top and bottom 10% of values?" +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/0087_320_87320991_qa_1/instruction.md b/tasks/0087_320_87320991_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f50257bc8807bb9d1bb46f158b645c3b7b3af242 --- /dev/null +++ b/tasks/0087_320_87320991_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature was identified as the most important variable for predicting mobile price ranges using the ExtraTreesClassifier feature importance analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0087_320_87320991_qa_1/task.toml b/tasks/0087_320_87320991_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..960fad7af5a6d6563a3732e5173a55c36641494f --- /dev/null +++ b/tasks/0087_320_87320991_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0087_320_87320991_qa_1" +description = "Which feature was identified as the most important variable for predicting mobile price ranges using the ExtraTreesClassifier feature importance analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0087/320/87320991.ipynb_qa_1" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "ram" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "ram" +QUESTION = "Which feature was identified as the most important variable for predicting mobile price ranges using the ExtraTreesClassifier feature importance analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0088_409_88409114_qa_4/instruction.md b/tasks/0088_409_88409114_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..175b7650f274e3316b7ea756a045eef3e1b30a0f --- /dev/null +++ b/tasks/0088_409_88409114_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): +- Salary_Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the YearsExperience coefficient in the regression model statistically significant at the 0.05 significance level? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0088_409_88409114_qa_4/task.toml b/tasks/0088_409_88409114_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8c79be557bcab2ea8eb920240a595363a62958a5 --- /dev/null +++ b/tasks/0088_409_88409114_qa_4/task.toml @@ -0,0 +1,56 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0088_409_88409114_qa_4" +description = "Is the YearsExperience coefficient in the regression model statistically significant at the 0.05 significance level?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0088/409/88409114.ipynb_qa_4" +kaggle_dataset_name = "karthickveerakumar/salary-data-simple-linear-regression" +gold_answer = "Yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "Yes" +QUESTION = "Is the YearsExperience coefficient in the regression model statistically significant at the 0.05 significance level?" +REWARD_MODE = "exact_bool" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0090_524_90524053_qa_2/instruction.md b/tasks/0090_524_90524053_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c22efb748909540af3274444dd31e8ff73de3fb0 --- /dev/null +++ b/tasks/0090_524_90524053_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which physicochemical property shows the strongest positive correlation with wine quality? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0090_524_90524053_qa_2/task.toml b/tasks/0090_524_90524053_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..038c0a051e5960609284ab6b5524d6738b7f93a3 --- /dev/null +++ b/tasks/0090_524_90524053_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0090_524_90524053_qa_2" +description = "Which physicochemical property shows the strongest positive correlation with wine quality?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0090/524/90524053.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "alcohol" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__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 physicochemical property shows the strongest positive correlation with wine quality?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0095_223_95223929_qa_4/instruction.md b/tasks/0095_223_95223929_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..93d98b8b931ee789e375f184e0a67b1c5c188314 --- /dev/null +++ b/tasks/0095_223_95223929_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest absolute coefficient value in the Linear Regression model's final equation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0095_223_95223929_qa_4/task.toml b/tasks/0095_223_95223929_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0353bac842a2bf3e7a05470cc9c4ab57c1d5a8d3 --- /dev/null +++ b/tasks/0095_223_95223929_qa_4/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0095_223_95223929_qa_4" +description = "Which feature has the highest absolute coefficient value in the Linear Regression model's final equation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0095/223/95223929.ipynb_qa_4" +kaggle_dataset_name = "altavish/boston-housing-dataset" +gold_answer = "NOX" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "altavish__boston-housing-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "altavish/boston-housing-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "NOX" +QUESTION = "Which feature has the highest absolute coefficient value in the Linear Regression model's final equation?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0100_711_100711073_qa_2/instruction.md b/tasks/0100_711_100711073_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ae1d8fcc34c355e1039d10fd9b8d9953ca2b6237 --- /dev/null +++ b/tasks/0100_711_100711073_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique customers are present in the cleaned dataset after removing records with missing CustomerID 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/0100_711_100711073_qa_2/task.toml b/tasks/0100_711_100711073_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..76e67b78750aeb42c1344d21fbd231f31bb8b399 --- /dev/null +++ b/tasks/0100_711_100711073_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0100_711_100711073_qa_2" +description = "How many unique customers are present in the cleaned dataset after removing records with missing CustomerID values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0100/711/100711073.ipynb_qa_2" +kaggle_dataset_name = "vijayuv/onlineretail" +gold_answer = "4338" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "vijayuv__onlineretail" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vijayuv/onlineretail" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4338" +QUESTION = "How many unique customers are present in the cleaned dataset after removing records with missing CustomerID 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/0101_232_101232922_qa_1/instruction.md b/tasks/0101_232_101232922_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2bb2a782cc28ada228d1b0972eb9ee9d9349dbdd --- /dev/null +++ b/tasks/0101_232_101232922_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- concrete_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which material component shows the strongest positive correlation with concrete compressive strength according to the heatmap analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0101_232_101232922_qa_1/task.toml b/tasks/0101_232_101232922_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5a918e2103cec88b99494cbed554a30808b08b66 --- /dev/null +++ b/tasks/0101_232_101232922_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0101_232_101232922_qa_1" +description = "Which material component shows the strongest positive correlation with concrete compressive strength according to the heatmap analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/232/101232922.ipynb_qa_1" +kaggle_dataset_name = "elikplim/concrete-compressive-strength-data-set" +gold_answer = "Cement" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "elikplim__concrete-compressive-strength-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "elikplim/concrete-compressive-strength-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Cement" +QUESTION = "Which material component shows the strongest positive correlation with concrete compressive strength according to the heatmap analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0101_917_101917756_qa_3/instruction.md b/tasks/0101_917_101917756_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..be4460ea36ef4e36660c24b59fb0295e0e8a1389 --- /dev/null +++ b/tasks/0101_917_101917756_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which contract type has the highest churn rate as observed in the dataset analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0101_917_101917756_qa_3/task.toml b/tasks/0101_917_101917756_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8aa595975559f12f05449c640bb8775bc581a412 --- /dev/null +++ b/tasks/0101_917_101917756_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0101_917_101917756_qa_3" +description = "Which contract type has the highest churn rate as observed in the dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0101/917/101917756.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "Month-to-month" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Month-to-month" +QUESTION = "Which contract type has the highest churn rate as observed in the dataset analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0103_514_103514732_qa_5/instruction.md b/tasks/0103_514_103514732_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c93baef0fd3217e0b21a89053f53f5b44a3eaea3 --- /dev/null +++ b/tasks/0103_514_103514732_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the original dataset was used for training based on the train-test split? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0103_514_103514732_qa_5/task.toml b/tasks/0103_514_103514732_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c5f8135fff344ba99b54a4092c3b32573fbbdadd --- /dev/null +++ b/tasks/0103_514_103514732_qa_5/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0103_514_103514732_qa_5" +description = "What percentage of the original dataset was used for training based on the train-test split?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0103/514/103514732.ipynb_qa_5" +kaggle_dataset_name = "limkongkong/airpassengers" +gold_answer = "80" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "limkongkong__airpassengers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "limkongkong/airpassengers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "80" +QUESTION = "What percentage of the original dataset was used for training based on the train-test split?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0109_666_109666127_qa_1/instruction.md b/tasks/0109_666_109666127_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f8d79bcb02928736f57af8055955a822b5f8cf26 --- /dev/null +++ b/tasks/0109_666_109666127_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 year had the highest average voting based on the movie 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/0109_666_109666127_qa_1/task.toml b/tasks/0109_666_109666127_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0937220fe019703d24a9c7d416cfdfc82845f1c3 --- /dev/null +++ b/tasks/0109_666_109666127_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0109_666_109666127_qa_1" +description = "Which year had the highest average voting based on the movie data analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0109/666/109666127.ipynb_qa_1" +kaggle_dataset_name = "PromptCloudHQ/imdb-data" +gold_answer = "2012" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "PromptCloudHQ__imdb-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "PromptCloudHQ/imdb-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2012" +QUESTION = "Which year had the highest average voting based on the movie data analysis?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0111_310_111310845_qa_2/instruction.md b/tasks/0111_310_111310845_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3a1d9dd3e3aa7046daf39e33c59d1ceab0748213 --- /dev/null +++ b/tasks/0111_310_111310845_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which nationality has the highest number of represented artists in the dataset (excluding "Nationality unknown" entries)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0111_310_111310845_qa_2/task.toml b/tasks/0111_310_111310845_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7d4e1831a56f4c0241b94d35208106580d860d57 --- /dev/null +++ b/tasks/0111_310_111310845_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0111_310_111310845_qa_2" +description = "Which nationality has the highest number of represented artists in the dataset (excluding \"Nationality unknown\" entries)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0111/310/111310845.ipynb_qa_2" +kaggle_dataset_name = "momanyc/museum-collection" +gold_answer = "American" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "momanyc__museum-collection" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "momanyc/museum-collection" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "American" +QUESTION = "Which nationality has the highest number of represented artists in the dataset (excluding \"Nationality unknown\" entries)?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0116_898_116898391_qa_3/instruction.md b/tasks/0116_898_116898391_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e404b68e21eee1166b9df9c4d584ed260bbcc289 --- /dev/null +++ b/tasks/0116_898_116898391_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average house price in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0116_898_116898391_qa_3/task.toml b/tasks/0116_898_116898391_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c1b23b00989083c98e235ea45c43adb952d41249 --- /dev/null +++ b/tasks/0116_898_116898391_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0116_898_116898391_qa_3" +description = "What is the average house price in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0116/898/116898391.ipynb_qa_3" +kaggle_dataset_name = "vedavyasv/usa-housing" +gold_answer = "1232073.0" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "vedavyasv__usa-housing" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vedavyasv/usa-housing" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1232073.0" +QUESTION = "What is the average house price in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0119_986_119986677_qa_3/instruction.md b/tasks/0119_986_119986677_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fb5935e618bdbea17838d127d1d57f2be5c40cad --- /dev/null +++ b/tasks/0119_986_119986677_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which video game was sold the most times (highest count of entries) across all regions? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0119_986_119986677_qa_3/task.toml b/tasks/0119_986_119986677_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8775d71c5cddfa14f6e22f9ed696a2ee8ca21d10 --- /dev/null +++ b/tasks/0119_986_119986677_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0119_986_119986677_qa_3" +description = "Which video game was sold the most times (highest count of entries) across all regions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0119/986/119986677.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Need for Speed: Most Wanted" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Need for Speed: Most Wanted" +QUESTION = "Which video game was sold the most times (highest count of entries) across all regions?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0121_947_121947601_qa_1/instruction.md b/tasks/0121_947_121947601_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4a3220c8881b74908baad6487c5943dec637786d --- /dev/null +++ b/tasks/0121_947_121947601_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): +- german_credit_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of missing values in the dataset before imputation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0121_947_121947601_qa_1/task.toml b/tasks/0121_947_121947601_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b87b668e228f2c1c3fb866662b37ad20e4e2b314 --- /dev/null +++ b/tasks/0121_947_121947601_qa_1/task.toml @@ -0,0 +1,57 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0121_947_121947601_qa_1" +description = "What is the percentage of missing values in the dataset before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0121/947/121947601.ipynb_qa_1" +kaggle_dataset_name = "kabure/german-credit-data-with-risk" +gold_answer = "5.245%" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 2 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kabure__german-credit-data-with-risk" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kabure/german-credit-data-with-risk" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5.245%" +QUESTION = "What is the percentage of missing values in the dataset before imputation?" +REWARD_MODE = "flexible" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0123_500_123500011_qa_2/instruction.md b/tasks/0123_500_123500011_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bd8afc4632578ef3c3816b68fb8e5678e1a91ba3 --- /dev/null +++ b/tasks/0123_500_123500011_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Pokémon type has the highest number of Pokémon in the dataset, and how many Pokémon belong to that type? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0123_500_123500011_qa_2/task.toml b/tasks/0123_500_123500011_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..47634b75ae1e388e8dcca00e58922cd4bf7f6294 --- /dev/null +++ b/tasks/0123_500_123500011_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0123_500_123500011_qa_2" +description = "Which Pokémon type has the highest number of Pokémon in the dataset, and how many Pokémon belong to that type?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0123/500/123500011.ipynb_qa_2" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "Water type with 112 Pokémon." +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Water type with 112 Pokémon." +QUESTION = "Which Pokémon type has the highest number of Pokémon in the dataset, and how many Pokémon belong to that type?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0129_395_129395519_qa_2/instruction.md b/tasks/0129_395_129395519_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a6933d903be1cb017ae1fdcc749145af5f0b2b35 --- /dev/null +++ b/tasks/0129_395_129395519_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: +By how many standard deviations above the North American sales mean is the top-selling game in North America? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0129_395_129395519_qa_2/task.toml b/tasks/0129_395_129395519_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4fe635cfd9135e7fb1afae35e65966b4fb2e5922 --- /dev/null +++ b/tasks/0129_395_129395519_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0129_395_129395519_qa_2" +description = "By how many standard deviations above the North American sales mean is the top-selling game in North America?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0129/395/129395519.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "50.48 standard deviations above the mean." +reward_mode_initial = "flexible" +package_tier = 3 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "50.48 standard deviations above the mean." +QUESTION = "By how many standard deviations above the North American sales mean is the top-selling game in North America?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0130_615_130615633_qa_2/instruction.md b/tasks/0130_615_130615633_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..315236df1c2ed4fc12c030a5d3a9c3eccef1b60b --- /dev/null +++ b/tasks/0130_615_130615633_qa_2/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the range of the target variable (y) in the cleaned training dataset after removing the outlier at index 213? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0130_615_130615633_qa_2/task.toml b/tasks/0130_615_130615633_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..748af2231ac178bf0e466c0a216a76bcfa986374 --- /dev/null +++ b/tasks/0130_615_130615633_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0130_615_130615633_qa_2" +description = "What is the range of the target variable (y) in the cleaned training dataset after removing the outlier at index 213?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0130/615/130615633.ipynb_qa_2" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "(-3.83998112, 108.8716183)" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "(-3.83998112, 108.8716183)" +QUESTION = "What is the range of the target variable (y) in the cleaned training dataset after removing the outlier at index 213? Express the answer as a tuple of (min, max) values." +REWARD_MODE = "list" +ATOL = "1e-4" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0132_566_132566728_qa_2/instruction.md b/tasks/0132_566_132566728_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f32cab0a267790a41b7bc1e03ed121487cbbf93a --- /dev/null +++ b/tasks/0132_566_132566728_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 removing highly correlated features to reduce multicollinearity, which seven categorical features were specifically excluded from the 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/0132_566_132566728_qa_2/task.toml b/tasks/0132_566_132566728_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..09f78f1564de39eee7a816ae67c760262517390e --- /dev/null +++ b/tasks/0132_566_132566728_qa_2/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0132_566_132566728_qa_2" +description = "After removing highly correlated features to reduce multicollinearity, which seven categorical features were specifically excluded from the analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0132/566/132566728.ipynb_qa_2" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "MultipleLines, OnlineSecurity, OnlineBackup, DeviceProtection, TechSupport, StreamingTV, StreamingMovies" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "MultipleLines, OnlineSecurity, OnlineBackup, DeviceProtection, TechSupport, StreamingTV, StreamingMovies" +QUESTION = "After removing highly correlated features to reduce multicollinearity, which seven categorical features were specifically excluded from the 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/0136_825_136825945_qa_1/instruction.md b/tasks/0136_825_136825945_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cf11d0ba2fd75d2bee2c703715a03c758268f343 --- /dev/null +++ b/tasks/0136_825_136825945_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many Pokémon have both Fire as their primary type and Flying as their secondary type? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0136_825_136825945_qa_1/task.toml b/tasks/0136_825_136825945_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1abf50054c5bd2e4838e2f843fabe8dbbf81a4cb --- /dev/null +++ b/tasks/0136_825_136825945_qa_1/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0136_825_136825945_qa_1" +description = "How many Pokémon have both Fire as their primary type and Flying as their secondary type?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0136/825/136825945.ipynb_qa_1" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "6" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "6" +QUESTION = "How many Pokémon have both Fire as their primary type and Flying as their secondary type?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0136_874_136874999_qa_3/instruction.md b/tasks/0136_874_136874999_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f388d20805ca6494132c3ced7965141efbacd9b6 --- /dev/null +++ b/tasks/0136_874_136874999_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): +- class.csv +- zoo.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which animal class has the lowest number of species in the dataset, and how many species belong to this class? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0136_874_136874999_qa_3/task.toml b/tasks/0136_874_136874999_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2c1597f9ac16aaf3799be7a113019a21c8d5dff5 --- /dev/null +++ b/tasks/0136_874_136874999_qa_3/task.toml @@ -0,0 +1,63 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0136_874_136874999_qa_3" +description = "Which animal class has the lowest number of species in the dataset, and how many species belong to this class?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0136/874/136874999.ipynb_qa_3" +kaggle_dataset_name = "uciml/zoo-animal-classification" +gold_answer = "Amphibian with 4 species" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 0 + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__zoo-animal-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/zoo-animal-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Amphibian with 4 species" +QUESTION = "Which animal class has the lowest number of species in the dataset, and how many species belong to this class?" +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]