diff --git a/tasks/0001_257_1257756_qa_3/instruction.md b/tasks/0001_257_1257756_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..da1d5bdf9b551b60eb69df09fa279048cdc4ed6c --- /dev/null +++ b/tasks/0001_257_1257756_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): +- FMEL_Dataset.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average total number of goals scored per match in the dataset (local + visitor goals)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_257_1257756_qa_3/task.toml b/tasks/0001_257_1257756_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7fccc3aef7d92885f35042bcd6506683302e1562 --- /dev/null +++ b/tasks/0001_257_1257756_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_257_1257756_qa_3" +description = "What is the average total number of goals scored per match in the dataset (local + visitor goals)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/257/1257756.ipynb_qa_3" +kaggle_dataset_name = "ricardomoya/football-matches-of-spanish-league" +gold_answer = "2.45" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "ricardomoya__football-matches-of-spanish-league" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ricardomoya/football-matches-of-spanish-league" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2.45" +QUESTION = "What is the average total number of goals scored per match in the dataset (local + visitor goals)?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_289_1289812_qa_4/instruction.md b/tasks/0001_289_1289812_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5f980acfd081bc30962927c5db72afcb1bfb0596 --- /dev/null +++ b/tasks/0001_289_1289812_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): +- Netflix Shows.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many Netflix shows in the dataset contain missing values in at least one column? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_289_1289812_qa_4/task.toml b/tasks/0001_289_1289812_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b57ca25c397d671d4aaf0e5d7f24f0b483ceb982 --- /dev/null +++ b/tasks/0001_289_1289812_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_289_1289812_qa_4" +description = "How many Netflix shows in the dataset contain missing values in at least one column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/289/1289812.ipynb_qa_4" +kaggle_dataset_name = "chasewillden/netflix-shows" +gold_answer = "426" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "chasewillden__netflix-shows" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "chasewillden/netflix-shows" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "426" +QUESTION = "How many Netflix shows in the dataset contain missing values in at least one column?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_404_1404790_qa_3/instruction.md b/tasks/0001_404_1404790_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..885fd6d72ff5c1fe954b7778fa5322c01acc7e58 --- /dev/null +++ b/tasks/0001_404_1404790_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many transactions are present in the resampled dataset after applying under-sampling to balance the classes? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_404_1404790_qa_3/task.toml b/tasks/0001_404_1404790_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d00c890590dba6196787d8232ea7d8bb0bc280b3 --- /dev/null +++ b/tasks/0001_404_1404790_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_404_1404790_qa_3" +description = "How many transactions are present in the resampled dataset after applying under-sampling to balance the classes?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/404/1404790.ipynb_qa_3" +kaggle_dataset_name = "mlg-ulb/creditcardfraud" +gold_answer = "984" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mlg-ulb__creditcardfraud" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mlg-ulb/creditcardfraud" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "984" +QUESTION = "How many transactions are present in the resampled dataset after applying under-sampling to balance the classes?" +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_604_1604140_qa_4/instruction.md b/tasks/0001_604_1604140_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b6407c909254f9747c3ebc212d57f5c92a08e82d --- /dev/null +++ b/tasks/0001_604_1604140_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 weekday experiences the highest frequency of mass shootings based on the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_604_1604140_qa_4/task.toml b/tasks/0001_604_1604140_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..28ba0d5661b48936e4dec85a532cdcd940acb5b9 --- /dev/null +++ b/tasks/0001_604_1604140_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_604_1604140_qa_4" +description = "Which weekday experiences the highest frequency of mass shootings based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/604/1604140.ipynb_qa_4" +kaggle_dataset_name = "zusmani/us-mass-shootings-last-50-years" +gold_answer = "Thursday" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zusmani__us-mass-shootings-last-50-years" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zusmani/us-mass-shootings-last-50-years" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Thursday" +QUESTION = "Which weekday experiences the highest frequency of mass shootings based on the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_667_1667317_qa_5/instruction.md b/tasks/0001_667_1667317_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c80f7de12d47e531f145aba57ecf9e68ea6a41dc --- /dev/null +++ b/tasks/0001_667_1667317_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): +- camera_dataset.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum Storage included capacity recorded for any camera 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_667_1667317_qa_5/task.toml b/tasks/0001_667_1667317_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5f11d57d0657533bdbde118e6a1599f9bc9ad06f --- /dev/null +++ b/tasks/0001_667_1667317_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_667_1667317_qa_5" +description = "What is the maximum Storage included capacity recorded for any camera in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/667/1667317.ipynb_qa_5" +kaggle_dataset_name = "crawford/1000-cameras-dataset" +gold_answer = "450" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__1000-cameras-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/1000-cameras-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "450" +QUESTION = "What is the maximum Storage included capacity recorded for any camera in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_840_1840182_qa_2/instruction.md b/tasks/0001_840_1840182_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..06dc2805ef10e9c41469daae6df2a866da2f0654 --- /dev/null +++ b/tasks/0001_840_1840182_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winemag-data-130k-v2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which wine taster has assigned the highest average rating to wines they reviewed? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_840_1840182_qa_2/task.toml b/tasks/0001_840_1840182_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..00a58a31fd80d2a0c940a9b1e21fca13c44ff52c --- /dev/null +++ b/tasks/0001_840_1840182_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_840_1840182_qa_2" +description = "Which wine taster has assigned the highest average rating to wines they reviewed?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/840/1840182.ipynb_qa_2" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "Anne Krebiehl MW" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Anne Krebiehl MW" +QUESTION = "Which wine taster has assigned the highest average rating to wines they reviewed?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_878_1878746_qa_2/instruction.md b/tasks/0001_878_1878746_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..85a5012aed62601ecfcf246f27d8b8d63d5bdf62 --- /dev/null +++ b/tasks/0001_878_1878746_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the standard deviation of sugar content across all cereals 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_878_1878746_qa_2/task.toml b/tasks/0001_878_1878746_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..68cabe1d3e3ce0add9865e24fedb4b7921fb6256 --- /dev/null +++ b/tasks/0001_878_1878746_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_878_1878746_qa_2" +description = "What is the standard deviation of sugar content across all cereals in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/878/1878746.ipynb_qa_2" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "4.444885" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4.444885" +QUESTION = "What is the standard deviation of sugar content across all cereals 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_898_1898542_qa_4/instruction.md b/tasks/0001_898_1898542_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0d534435eda82abdc1832b42f3027dd3aaef4161 --- /dev/null +++ b/tasks/0001_898_1898542_qa_4/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many entries in the training dataset have missing values for the 'Embarked' feature? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_898_1898542_qa_4/task.toml b/tasks/0001_898_1898542_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..22d4381d65b103b652577daf68facced303a6e90 --- /dev/null +++ b/tasks/0001_898_1898542_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_898_1898542_qa_4" +description = "How many entries in the training dataset have missing values for the 'Embarked' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/898/1898542.ipynb_qa_4" +kaggle_dataset_name = "robinreni/titanic-dataset" +gold_answer = "2" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "robinreni__titanic-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "robinreni/titanic-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "How many entries in the training dataset have missing values for the 'Embarked' feature?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0002_144_2144947_qa_1/instruction.md b/tasks/0002_144_2144947_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..190107872467ca3a7ddd46fad9b42b30673d915c --- /dev/null +++ b/tasks/0002_144_2144947_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): +- titanic_train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of Age data was missing in the original 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/0002_144_2144947_qa_1/task.toml b/tasks/0002_144_2144947_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2017513b42e5ad7242713a761a748b2501b74a69 --- /dev/null +++ b/tasks/0002_144_2144947_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0002_144_2144947_qa_1" +description = "What percentage of Age data was missing in the original dataset before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/144/2144947.ipynb_qa_1" +kaggle_dataset_name = "abbasit/titanic" +gold_answer = "20" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abbasit__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abbasit/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "20" +QUESTION = "What percentage of Age data was missing in the original dataset before imputation?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0002_157_2157761_qa_1/instruction.md b/tasks/0002_157_2157761_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f31d128895eff7e3a153d4a3f751de63996cbbef --- /dev/null +++ b/tasks/0002_157_2157761_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): +- crime.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which year had the highest total number of crimes in Vancouver according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0002_157_2157761_qa_1/task.toml b/tasks/0002_157_2157761_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e90d191ccc1b9e1d12485ab7f5117ec54264eb9c --- /dev/null +++ b/tasks/0002_157_2157761_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0002_157_2157761_qa_1" +description = "Which year had the highest total number of crimes in Vancouver according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/157/2157761.ipynb_qa_1" +kaggle_dataset_name = "wosaku/crime-in-vancouver" +gold_answer = "2003" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "wosaku__crime-in-vancouver" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wosaku/crime-in-vancouver" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2003" +QUESTION = "Which year had the highest total number of crimes in Vancouver according to the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0002_158_2158528_qa_4/instruction.md b/tasks/0002_158_2158528_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..be954aa3c34e6e0b82b7ebb3b37721e0e466789c --- /dev/null +++ b/tasks/0002_158_2158528_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): +- Financial Distress.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct values does the x80 feature have in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0002_158_2158528_qa_4/task.toml b/tasks/0002_158_2158528_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..53e29cf6779f2cb7ebfd624a8c558ec62bf6e0c8 --- /dev/null +++ b/tasks/0002_158_2158528_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0002_158_2158528_qa_4" +description = "How many distinct values does the x80 feature have in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/158/2158528.ipynb_qa_4" +kaggle_dataset_name = "shebrahimi/financial-distress" +gold_answer = "37" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shebrahimi__financial-distress" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shebrahimi/financial-distress" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "37" +QUESTION = "How many distinct values does the x80 feature have 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/0002_234_2234436_qa_1/instruction.md b/tasks/0002_234_2234436_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..129ebd87b43cc96a8ed61e98f22925e509da6af3 --- /dev/null +++ b/tasks/0002_234_2234436_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): +- Salaries.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median TotalPay for full-time (FT) employees 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/0002_234_2234436_qa_1/task.toml b/tasks/0002_234_2234436_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bd145d270f75f9b6220720901ff7375366254e4a --- /dev/null +++ b/tasks/0002_234_2234436_qa_1/task.toml @@ -0,0 +1,60 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0002_234_2234436_qa_1" +description = "What is the median TotalPay for full-time (FT) employees based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/234/2234436.ipynb_qa_1" +kaggle_dataset_name = "kaggle/sf-salaries" +gold_answer = "94271.735" +reward_mode_initial = "numeric" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kaggle__sf-salaries" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kaggle/sf-salaries" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "94271.735" +QUESTION = "What is the median TotalPay for full-time (FT) employees based on the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0010_376_10376491_qa_3/instruction.md b/tasks/0010_376_10376491_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f3e0ec95f646df2883d6e710e2496c6d8cd117fd --- /dev/null +++ b/tasks/0010_376_10376491_qa_3/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average texture_mean for benign and malignant tumors in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: