diff --git a/tasks/0000_369_369503_qa_1/instruction.md b/tasks/0000_369_369503_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a9c107f4e4ae3e75ac952ed09ed9df5b0142853c --- /dev/null +++ b/tasks/0000_369_369503_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of all matches have a goal difference of zero (i.e., draws)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Express the value as a percentage (e.g. 95.5), not a fraction. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0000_369_369503_qa_1/task.toml b/tasks/0000_369_369503_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3ea7f9a117e571da64265fcf3400d7e04cc38c43 --- /dev/null +++ b/tasks/0000_369_369503_qa_1/task.toml @@ -0,0 +1,58 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0000_369_369503_qa_1" +description = "What percentage of all matches have a goal difference of zero (i.e., draws)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/369/369503.ipynb_qa_1" +kaggle_dataset_name = "hugomathien/soccer" +gold_answer = "25.4%" +reward_mode_initial = "flexible" +package_tier = 3 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 2 +memory_mb = 4096 +storage_mb = 10240 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "hugomathien__soccer" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hugomathien/soccer" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "25.4%" +QUESTION = "What percentage of all matches have a goal difference of zero (i.e., draws)?" +REWARD_MODE = "flexible" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0000_465_465850_qa_5/instruction.md b/tasks/0000_465_465850_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..35063d32184c7fcb24cfb2e0afd00b6280ead578 --- /dev/null +++ b/tasks/0000_465_465850_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): +- Iris.csv +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which species exhibits the highest average sepal length according to the aggregated dataset statistics? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_465_465850_qa_5/task.toml b/tasks/0000_465_465850_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..374d4313e41bf2d3fc12ef44c406349a68041831 --- /dev/null +++ b/tasks/0000_465_465850_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0000_465_465850_qa_5" +description = "Which species exhibits the highest average sepal length according to the aggregated dataset statistics?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/465/465850.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "virginica" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "virginica" +QUESTION = "Which species exhibits the highest average sepal length according to the aggregated dataset statistics?" +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/0000_804_804467_qa_3/instruction.md b/tasks/0000_804_804467_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b2ec4d087c0aae68e98eb4940d5543e52746c449 --- /dev/null +++ b/tasks/0000_804_804467_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): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the lowest RMSE value observed in the train_test_split results, and which models achieved it? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list: , , , (value first, then exact model names). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0000_804_804467_qa_3/task.toml b/tasks/0000_804_804467_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0249c177b4c5e7b05557904f739f5652e1d4ebcf --- /dev/null +++ b/tasks/0000_804_804467_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0000_804_804467_qa_3" +description = "What is the lowest RMSE value observed in the train_test_split results, and which models achieved it?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0000/804/804467.ipynb_qa_3" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "0, DecisionTree, RandomForest, SVM" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0, DecisionTree, RandomForest, SVM" +QUESTION = "What is the lowest RMSE value observed in the train_test_split results, and which models achieved it?" +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_074_1074738_qa_1/instruction.md b/tasks/0001_074_1074738_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..07d5a955bb1c92e642c9884fe1eaa4a26ee7fc81 --- /dev/null +++ b/tasks/0001_074_1074738_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- database.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which U.S. state has the highest number of recorded "Murder or Manslaughter" cases, and what is the exact count of such incidents in that state? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, state first, plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_074_1074738_qa_1/task.toml b/tasks/0001_074_1074738_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5de8e664f002c0ef4dde5b9d509f99bdfd364ea5 --- /dev/null +++ b/tasks/0001_074_1074738_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_074_1074738_qa_1" +description = "Which U.S. state has the highest number of recorded \"Murder or Manslaughter\" cases, and what is the exact count of such incidents in that state?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/074/1074738.ipynb_qa_1" +kaggle_dataset_name = "murderaccountability/homicide-reports" +gold_answer = "California, 98994" +reward_mode_initial = "list" +package_tier = 3 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "murderaccountability__homicide-reports" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "murderaccountability/homicide-reports" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "California, 98994" +QUESTION = "Which U.S. state has the highest number of recorded \"Murder or Manslaughter\" cases, and what is the exact count of such incidents in that state?" +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_137_1137361_qa_2/instruction.md b/tasks/0001_137_1137361_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..799a9aeb6913eb336fa51d7d5cadbc0a7e499ef4 --- /dev/null +++ b/tasks/0001_137_1137361_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): +- dataset_TSMC2014_NYC.csv +- dataset_TSMC2014_TKY.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 check-ins recorded in the New York City 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_137_1137361_qa_2/task.toml b/tasks/0001_137_1137361_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ee38d741bd2ab58805e5db64554c0fb5bc2191da --- /dev/null +++ b/tasks/0001_137_1137361_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_137_1137361_qa_2" +description = "What is the total number of check-ins recorded in the New York City dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/137/1137361.ipynb_qa_2" +kaggle_dataset_name = "chetanism/foursquare-nyc-and-tokyo-checkin-dataset" +gold_answer = "227428" +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 = "chetanism__foursquare-nyc-and-tokyo-checkin-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "chetanism/foursquare-nyc-and-tokyo-checkin-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "227428" +QUESTION = "What is the total number of check-ins recorded in the New York City 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_202_1202888_qa_1/instruction.md b/tasks/0001_202_1202888_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a3d220bed997a16b6cc35a1411286d6f2cdaac02 --- /dev/null +++ b/tasks/0001_202_1202888_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which generation has the highest probability of producing a legendary Pokémon in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_202_1202888_qa_1/task.toml b/tasks/0001_202_1202888_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b0f0680548875385c5df8ad60acdd895e8e1c5b5 --- /dev/null +++ b/tasks/0001_202_1202888_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_202_1202888_qa_1" +description = "Which generation has the highest probability of producing a legendary Pokémon in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/202/1202888.ipynb_qa_1" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "Generation 3" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Generation 3" +QUESTION = "Which generation has the highest probability of producing a legendary Pokémon in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_231_1231918_qa_1/instruction.md b/tasks/0001_231_1231918_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1c8f7f740025abcf1345bd1954952d7e0172dcfc --- /dev/null +++ b/tasks/0001_231_1231918_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- menu.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of McDonald's menu items contain zero sugar 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_231_1231918_qa_1/task.toml b/tasks/0001_231_1231918_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c4601875a872dc83d2fafdb5207590ebde62d54b --- /dev/null +++ b/tasks/0001_231_1231918_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_231_1231918_qa_1" +description = "What percentage of McDonald's menu items contain zero sugar based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/231/1231918.ipynb_qa_1" +kaggle_dataset_name = "mcdonalds/nutrition-facts" +gold_answer = "9.61" +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 = "mcdonalds__nutrition-facts" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mcdonalds/nutrition-facts" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "9.61" +QUESTION = "What percentage of McDonald's menu items contain zero sugar based on the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_233_1233959_qa_2/instruction.md b/tasks/0001_233_1233959_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e66d5d490b6a1c295deccca1e6289a1b6d5f7102 --- /dev/null +++ b/tasks/0001_233_1233959_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common cap shape in the dataset based on the feature frequency analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_233_1233959_qa_2/task.toml b/tasks/0001_233_1233959_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..72bdccb22ab65683df71d684100b868d279ea610 --- /dev/null +++ b/tasks/0001_233_1233959_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_233_1233959_qa_2" +description = "What is the most common cap shape in the dataset based on the feature frequency analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/233/1233959.ipynb_qa_2" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "convex" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "convex" +QUESTION = "What is the most common cap shape in the dataset based on the feature frequency analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_233_1233959_qa_5/instruction.md b/tasks/0001_233_1233959_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e15fdb6b8776c27ab72af2d9fa84a5def3ce3945 --- /dev/null +++ b/tasks/0001_233_1233959_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): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common cap color in the dataset based on the feature frequency analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_233_1233959_qa_5/task.toml b/tasks/0001_233_1233959_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1517386d2ea3ebc937bd7ba1247a06ef5a90cae9 --- /dev/null +++ b/tasks/0001_233_1233959_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_233_1233959_qa_5" +description = "What is the most common cap color in the dataset based on the feature frequency analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/233/1233959.ipynb_qa_5" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "brown" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "brown" +QUESTION = "What is the most common cap color in the dataset based on the feature frequency analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_257_1257061_qa_1/instruction.md b/tasks/0001_257_1257061_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8bff2f6ca55b2473166388c430bab514c144cf92 --- /dev/null +++ b/tasks/0001_257_1257061_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the skewness of the original SalePrice distribution before any transformation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_257_1257061_qa_1/task.toml b/tasks/0001_257_1257061_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b9c55515247f46e02cc6097029ed2c3ff728e7fe --- /dev/null +++ b/tasks/0001_257_1257061_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_257_1257061_qa_1" +description = "What is the skewness of the original SalePrice distribution before any transformation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/257/1257061.ipynb_qa_1" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "4.024069" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4.024069" +QUESTION = "What is the skewness of the original SalePrice distribution before any transformation?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_277_1277058_qa_2/instruction.md b/tasks/0001_277_1277058_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0c0812e6ae4279596d740612f8fed7183f590296 --- /dev/null +++ b/tasks/0001_277_1277058_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- us_companies.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which year had the highest number of companies founded, and how many companies were founded that year? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated pair: , , with the year first and the count as a plain number. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_277_1277058_qa_2/task.toml b/tasks/0001_277_1277058_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2ee45a6287c2ddddc478824a30a942d979be0a26 --- /dev/null +++ b/tasks/0001_277_1277058_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_277_1277058_qa_2" +description = "Which year had the highest number of companies founded, and how many companies were founded that year?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/277/1277058.ipynb_qa_2" +kaggle_dataset_name = "govlab/open-data-500-companies" +gold_answer = "2011, 51" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "govlab__open-data-500-companies" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "govlab/open-data-500-companies" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2011, 51" +QUESTION = "Which year had the highest number of companies founded, and how many companies were founded that year?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_323_1323152_qa_1/instruction.md b/tasks/0001_323_1323152_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9523bb75a160466f5e2c45cd38950f11cfd91ac3 --- /dev/null +++ b/tasks/0001_323_1323152_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- IMDB-Movie-Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which movie generated the highest revenue in the dataset, and what was the exact revenue amount? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, title first, keep decimals). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_323_1323152_qa_1/task.toml b/tasks/0001_323_1323152_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..88017c790385fc21ec0b5b1276f85fed15eac88c --- /dev/null +++ b/tasks/0001_323_1323152_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_323_1323152_qa_1" +description = "Which movie generated the highest revenue in the dataset, and what was the exact revenue amount?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/323/1323152.ipynb_qa_1" +kaggle_dataset_name = "PromptCloudHQ/imdb-data" +gold_answer = "Star Wars: Episode VII - The Force Awakens, 936.63" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "PromptCloudHQ__imdb-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "PromptCloudHQ/imdb-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Star Wars: Episode VII - The Force Awakens, 936.63" +QUESTION = "Which movie generated the highest revenue in the dataset, and what was the exact revenue amount?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_354_1354131_qa_1/instruction.md b/tasks/0001_354_1354131_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fba7837ea1dba5637a4e0bb8417ba09363adc629 --- /dev/null +++ b/tasks/0001_354_1354131_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the distribution of species in the Iris dataset balanced across all 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_354_1354131_qa_1/task.toml b/tasks/0001_354_1354131_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7e7acd1186a65cfd662e2050b5a84dba0de73a1f --- /dev/null +++ b/tasks/0001_354_1354131_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_354_1354131_qa_1" +description = "Is the distribution of species in the Iris dataset balanced across all classes?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/354/1354131.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the distribution of species in the Iris dataset balanced across all classes?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_364_1364936_qa_3/instruction.md b/tasks/0001_364_1364936_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..55c6e02ad98ff9b6160829917e421852688cbbf3 --- /dev/null +++ b/tasks/0001_364_1364936_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 movie has the lowest total count of entries in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_364_1364936_qa_3/task.toml b/tasks/0001_364_1364936_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b6d96bc4698d5b5f4220718230d29e1c69e8c74d --- /dev/null +++ b/tasks/0001_364_1364936_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_364_1364936_qa_3" +description = "Which movie has the lowest total count of entries in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/364/1364936.ipynb_qa_3" +kaggle_dataset_name = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" +gold_answer = "Kill Bill: Vol. 2" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "fivethirtyeight__cuss-words-and-deaths-in-quentin-tarantino-films" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Kill Bill: Vol. 2" +QUESTION = "Which movie has the lowest total count of entries in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_364_1364936_qa_4/instruction.md b/tasks/0001_364_1364936_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a1be24c28bbcf27a1cb8b13ae388b8e5df5a3073 --- /dev/null +++ b/tasks/0001_364_1364936_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): +- tarantino.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many movies in the dataset were released after the year 2004? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_364_1364936_qa_4/task.toml b/tasks/0001_364_1364936_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2956d1f54bada12a4efd5882d1e3cb23ddd1ffad --- /dev/null +++ b/tasks/0001_364_1364936_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_364_1364936_qa_4" +description = "How many movies in the dataset were released after the year 2004?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/364/1364936.ipynb_qa_4" +kaggle_dataset_name = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" +gold_answer = "2" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "fivethirtyeight__cuss-words-and-deaths-in-quentin-tarantino-films" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "fivethirtyeight/cuss-words-and-deaths-in-quentin-tarantino-films" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "How many movies in the dataset were released after the year 2004?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_367_1367107_qa_1/instruction.md b/tasks/0001_367_1367107_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d5454457d58700bdec0272129808d7dbe20cc97d --- /dev/null +++ b/tasks/0001_367_1367107_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- battles.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which pair of variables in the dataset has the strongest positive correlation according to the correlation matrix? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact column names. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_367_1367107_qa_1/task.toml b/tasks/0001_367_1367107_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..008d8ac833a7123a044d62773e1739494a59ec36 --- /dev/null +++ b/tasks/0001_367_1367107_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_367_1367107_qa_1" +description = "Which pair of variables in the dataset has the strongest positive correlation according to the correlation matrix?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/367/1367107.ipynb_qa_1" +kaggle_dataset_name = "mylesoneill/game-of-thrones" +gold_answer = "battle_number, year" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mylesoneill__game-of-thrones" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mylesoneill/game-of-thrones" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "battle_number, year" +QUESTION = "Which pair of variables in the dataset has the strongest positive correlation according to the correlation matrix?" +REWARD_MODE = "list_csv" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_374_1374329_qa_2/instruction.md b/tasks/0001_374_1374329_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d25091738f2a552560ccd0939e665b680d37930f --- /dev/null +++ b/tasks/0001_374_1374329_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Suicides in India 2001-2012.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common cause of suicide in the dataset according to 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/0001_374_1374329_qa_2/task.toml b/tasks/0001_374_1374329_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bcc4ac1a5495719f473e88e31c76bf38afd73a19 --- /dev/null +++ b/tasks/0001_374_1374329_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_374_1374329_qa_2" +description = "What is the most common cause of suicide in the dataset according to the analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/374/1374329.ipynb_qa_2" +kaggle_dataset_name = "rajanand/suicides-in-india" +gold_answer = "Family problems" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rajanand__suicides-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/suicides-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Family problems" +QUESTION = "What is the most common cause of suicide in the dataset according to the analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_374_1374329_qa_3/instruction.md b/tasks/0001_374_1374329_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..39d8c25a744741463486f4879ea628df56d76d8c --- /dev/null +++ b/tasks/0001_374_1374329_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Suicides in India 2001-2012.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which demographic group (based on social status) has the highest total number of suicides 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_374_1374329_qa_3/task.toml b/tasks/0001_374_1374329_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8d0c2ad76d44cb9ccb3c28d307c41fa5a11b817e --- /dev/null +++ b/tasks/0001_374_1374329_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_374_1374329_qa_3" +description = "Which demographic group (based on social status) has the highest total number of suicides in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/374/1374329.ipynb_qa_3" +kaggle_dataset_name = "rajanand/suicides-in-india" +gold_answer = "Married" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rajanand__suicides-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/suicides-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Married" +QUESTION = "Which demographic group (based on social status) has the highest total number of suicides in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_380_1380018_qa_1/instruction.md b/tasks/0001_380_1380018_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5f5cdcf94b8042e30d4e6e60ac55abf1a190e8c6 --- /dev/null +++ b/tasks/0001_380_1380018_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- rainfall in india 1901-2015.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Indian subdivision has the highest average annual rainfall, and what is the value in millimeters? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, keep decimals). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_380_1380018_qa_1/task.toml b/tasks/0001_380_1380018_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d04a91d0bd095cd2d75f9119aaf977331574cba8 --- /dev/null +++ b/tasks/0001_380_1380018_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_380_1380018_qa_1" +description = "Which Indian subdivision has the highest average annual rainfall, and what is the value in millimeters?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/380/1380018.ipynb_qa_1" +kaggle_dataset_name = "rajanand/rainfall-in-india" +gold_answer = "Arunachal Pradesh, 3418.86" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rajanand__rainfall-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/rainfall-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Arunachal Pradesh, 3418.86" +QUESTION = "Which Indian subdivision has the highest average annual rainfall, and what is the value in millimeters?" +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_413_1413239_qa_1/instruction.md b/tasks/0001_413_1413239_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..687955fbc335dd94ebb3188b22008d77ee8a474a --- /dev/null +++ b/tasks/0001_413_1413239_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many teams in the dataset have missing FIFA API IDs? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_413_1413239_qa_1/task.toml b/tasks/0001_413_1413239_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6622938626c6509f59bf19be3793a5bd89f42908 --- /dev/null +++ b/tasks/0001_413_1413239_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_413_1413239_qa_1" +description = "How many teams in the dataset have missing FIFA API IDs?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/413/1413239.ipynb_qa_1" +kaggle_dataset_name = "hugomathien/soccer" +gold_answer = "11" +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 = "hugomathien__soccer" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hugomathien/soccer" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11" +QUESTION = "How many teams in the dataset have missing FIFA API IDs?" +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_425_1425114_qa_5/instruction.md b/tasks/0001_425_1425114_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..252702b789348758f2a39792cf090e494d1e9104 --- /dev/null +++ b/tasks/0001_425_1425114_qa_5/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data_set_ALL_AML_train.csv +- actual.csv +- data_set_ALL_AML_independent.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the number of principal components used in the PCA analysis for dimensionality reduction? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_425_1425114_qa_5/task.toml b/tasks/0001_425_1425114_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..31dc08350995228ae420fc204ad1f389eba2be45 --- /dev/null +++ b/tasks/0001_425_1425114_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_425_1425114_qa_5" +description = "What is the number of principal components used in the PCA analysis for dimensionality reduction?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/425/1425114.ipynb_qa_5" +kaggle_dataset_name = "crawford/gene-expression" +gold_answer = "2" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__gene-expression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/gene-expression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "What is the number of principal components used in the PCA analysis for dimensionality reduction?" +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_426_1426219_qa_4/instruction.md b/tasks/0001_426_1426219_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..327c6f528eec33e450115e82ba7618af4ee49063 --- /dev/null +++ b/tasks/0001_426_1426219_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): +- Uniqlo(FastRetailing) 2012-2016 Training - stocks2012-2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of trading days recorded in the year 2012? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_426_1426219_qa_4/task.toml b/tasks/0001_426_1426219_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f17124e95656e9a04e0f85f844f58127c89e8c2b --- /dev/null +++ b/tasks/0001_426_1426219_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_426_1426219_qa_4" +description = "What is the total number of trading days recorded in the year 2012?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/426/1426219.ipynb_qa_4" +kaggle_dataset_name = "daiearth22/uniqlo-fastretailing-stock-price-prediction" +gold_answer = "248" +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 = "daiearth22__uniqlo-fastretailing-stock-price-prediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "daiearth22/uniqlo-fastretailing-stock-price-prediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "248" +QUESTION = "What is the total number of trading days recorded in the year 2012?" +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_448_1448587_qa_3/instruction.md b/tasks/0001_448_1448587_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5925bda6766fdb260efb2923697ed3743cbffb3f --- /dev/null +++ b/tasks/0001_448_1448587_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): +- FDI_in_India.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What were the FDI inflows for the METALLURGICAL INDUSTRIES sector in the four years 2013, 2014, 2015, and 2016? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the four values in the order 2013, 2014, 2015, 2016, with numbers as given (e.g., 567.63). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_448_1448587_qa_3/task.toml b/tasks/0001_448_1448587_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..08d40e63c98368e67926fdbbd8e587d378af79a6 --- /dev/null +++ b/tasks/0001_448_1448587_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_448_1448587_qa_3" +description = "What were the FDI inflows for the METALLURGICAL INDUSTRIES sector in the four years 2013, 2014, 2015, and 2016?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/448/1448587.ipynb_qa_3" +kaggle_dataset_name = "rajanand/fdi-in-india" +gold_answer = "567.63, 359.34, 456.31, 1440.18" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rajanand__fdi-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/fdi-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "567.63, 359.34, 456.31, 1440.18" +QUESTION = "What were the FDI inflows for the METALLURGICAL INDUSTRIES sector in the four years 2013, 2014, 2015, and 2016?" +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_520_1520172_qa_4/instruction.md b/tasks/0001_520_1520172_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1dfecaac02a091b1af1cd40f609f0d63d2ceb7fa --- /dev/null +++ b/tasks/0001_520_1520172_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- KaggleV2-May-2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of unique appointment dates in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_520_1520172_qa_4/task.toml b/tasks/0001_520_1520172_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..908dc4e77457eca0e7c267d6abe8064686659bfe --- /dev/null +++ b/tasks/0001_520_1520172_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_520_1520172_qa_4" +description = "What is the total number of unique appointment dates in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/520/1520172.ipynb_qa_4" +kaggle_dataset_name = "joniarroba/noshowappointments" +gold_answer = "27" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "joniarroba__noshowappointments" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "joniarroba/noshowappointments" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "27" +QUESTION = "What is the total number of unique appointment dates in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_598_1598981_qa_3/instruction.md b/tasks/0001_598_1598981_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cea6e87998369935f687d8f95e507f063dd54a16 --- /dev/null +++ b/tasks/0001_598_1598981_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): +- student-mat.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which student address type (urban 'U' or rural 'R') has the highest count in the dataset, and what is the specific number of students for that address type? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_598_1598981_qa_3/task.toml b/tasks/0001_598_1598981_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d087aeb99b708c84ec8b1504286490075b50e39c --- /dev/null +++ b/tasks/0001_598_1598981_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_598_1598981_qa_3" +description = "Which student address type (urban 'U' or rural 'R') has the highest count in the dataset, and what is the specific number of students for that address type?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/598/1598981.ipynb_qa_3" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "U, 307" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "U, 307" +QUESTION = "Which student address type (urban 'U' or rural 'R') has the highest count in the dataset, and what is the specific number of students for that address type?" +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_632_1632608_qa_2/instruction.md b/tasks/0001_632_1632608_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3b4f26181d208b15d1f983c530363ee9aa4fccef --- /dev/null +++ b/tasks/0001_632_1632608_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): +- UK_Traffic_Accidents_2015.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +During which hour of the day were traffic-related deaths most frequent on Fridays? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_632_1632608_qa_2/task.toml b/tasks/0001_632_1632608_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..db7cf82a5ac8a305c23e39df79cf9b2bb62b349d --- /dev/null +++ b/tasks/0001_632_1632608_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_632_1632608_qa_2" +description = "During which hour of the day were traffic-related deaths most frequent on Fridays?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/632/1632608.ipynb_qa_2" +kaggle_dataset_name = "kwullum/deadly-traffic-accidents-in-the-uk-2015" +gold_answer = "15:00" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kwullum__deadly-traffic-accidents-in-the-uk-2015" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kwullum/deadly-traffic-accidents-in-the-uk-2015" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "16" +QUESTION = "During which hour of the day were traffic-related deaths most frequent on Fridays?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_633_1633600_qa_1/instruction.md b/tasks/0001_633_1633600_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6df56fe701ed8aa28e5f676c8c0a1fb020ba204d --- /dev/null +++ b/tasks/0001_633_1633600_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): +- Daegu_Real_Estate_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest positive correlation coefficient between SalePrice and any numeric feature in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_633_1633600_qa_1/task.toml b/tasks/0001_633_1633600_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5bb37406b7a43a52c1d66d9b0bf824ec3727614e --- /dev/null +++ b/tasks/0001_633_1633600_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_633_1633600_qa_1" +description = "What is the highest positive correlation coefficient between SalePrice and any numeric feature in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/633/1633600.ipynb_qa_1" +kaggle_dataset_name = "gunhee/koreahousedata" +gold_answer = "0.697199" +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 = "gunhee__koreahousedata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gunhee/koreahousedata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.697199" +QUESTION = "What is the highest positive correlation coefficient between SalePrice and any numeric feature in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_660_1660748_qa_4/instruction.md b/tasks/0001_660_1660748_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d32ca5940459b948d7a553013436edfe57cd99f4 --- /dev/null +++ b/tasks/0001_660_1660748_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): +- anonymous-survey-responses.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the primary stated interest in data science for respondents with "quite a bit of programming experience"? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_660_1660748_qa_4/task.toml b/tasks/0001_660_1660748_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8fcb484d033cc1a9b83334274af7c7adcd538fdb --- /dev/null +++ b/tasks/0001_660_1660748_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_660_1660748_qa_4" +description = "What is the primary stated interest in data science for respondents with \"quite a bit of programming experience\"?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/660/1660748.ipynb_qa_4" +kaggle_dataset_name = "rtatman/5day-data-challenge-signup-survey-responses" +gold_answer = "I want to get a job where I use data science" +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 = "rtatman__5day-data-challenge-signup-survey-responses" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rtatman/5day-data-challenge-signup-survey-responses" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "I want to get a job where I use data science" +QUESTION = "What is the primary stated interest in data science for respondents with \"quite a bit of programming experience\"?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_662_1662961_qa_3/instruction.md b/tasks/0001_662_1662961_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6c77f318cf025bdf7eea9298b9c3168a8d560574 --- /dev/null +++ b/tasks/0001_662_1662961_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): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average sugar content in hot cereals? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_662_1662961_qa_3/task.toml b/tasks/0001_662_1662961_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4321abfa71d92c340d81ff756608b61575d64179 --- /dev/null +++ b/tasks/0001_662_1662961_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_662_1662961_qa_3" +description = "What is the average sugar content in hot cereals?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/662/1662961.ipynb_qa_3" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "0.6667" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.6667" +QUESTION = "What is the average sugar content in hot cereals?" +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_662_1662961_qa_5/instruction.md b/tasks/0001_662_1662961_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8d1a08bff00440c7cff867d7f5b59376edf71dde --- /dev/null +++ b/tasks/0001_662_1662961_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median sugar content in cold cereals? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_662_1662961_qa_5/task.toml b/tasks/0001_662_1662961_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d295ccdddb919433c18af87bfe6bff4fbc79db4b --- /dev/null +++ b/tasks/0001_662_1662961_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_662_1662961_qa_5" +description = "What is the median sugar content in cold cereals?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/662/1662961.ipynb_qa_5" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "7.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7.0" +QUESTION = "What is the median sugar content in cold cereals?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_725_1725548_qa_1/instruction.md b/tasks/0001_725_1725548_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bb609d91ed8aa9aee390ebc9264cbffc6af37b21 --- /dev/null +++ b/tasks/0001_725_1725548_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): +- English.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many verses (Ayah) have non-missing values in the dataset after processing? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_725_1725548_qa_1/task.toml b/tasks/0001_725_1725548_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..22499b7629cd16ce00f5caed2a1f12db915df29f --- /dev/null +++ b/tasks/0001_725_1725548_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_725_1725548_qa_1" +description = "How many verses (Ayah) have non-missing values in the dataset after processing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/725/1725548.ipynb_qa_1" +kaggle_dataset_name = "zusmani/the-holy-quran" +gold_answer = "4871" +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 = "zusmani__the-holy-quran" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zusmani/the-holy-quran" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4871" +QUESTION = "How many verses (Ayah) have non-missing values in the dataset after processing?" +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_735_1735855_qa_1/instruction.md b/tasks/0001_735_1735855_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f610c3d6beb0370d6fe2693b1e0010a1312a8f56 --- /dev/null +++ b/tasks/0001_735_1735855_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): +- en.yusufali.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequently occurring word in the dataset after removing common stopwords? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_735_1735855_qa_1/task.toml b/tasks/0001_735_1735855_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0dd1e8afd1301e116519329e95b4d9eb46ccab62 --- /dev/null +++ b/tasks/0001_735_1735855_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_735_1735855_qa_1" +description = "What is the most frequently occurring word in the dataset after removing common stopwords?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/735/1735855.ipynb_qa_1" +kaggle_dataset_name = "zusmani/the-holy-quran" +gold_answer = "allah" +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 = "zusmani__the-holy-quran" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zusmani/the-holy-quran" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "allah" +QUESTION = "What is the most frequently occurring word in the dataset after removing common stopwords?" +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_869_1869308_qa_4/instruction.md b/tasks/0001_869_1869308_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a0cd8866d407368853bbf11e5db7ac7758d585b6 --- /dev/null +++ b/tasks/0001_869_1869308_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median value of the carbohydrate content (carbo) 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_869_1869308_qa_4/task.toml b/tasks/0001_869_1869308_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8a0063226865dba5959e3950d17e1e86101789b7 --- /dev/null +++ b/tasks/0001_869_1869308_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_869_1869308_qa_4" +description = "What is the median value of the carbohydrate content (carbo) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/869/1869308.ipynb_qa_4" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "14.0" +reward_mode_initial = "numeric" +package_tier = 3 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "14.0" +QUESTION = "What is the median value of the carbohydrate content (carbo) in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_893_1893246_qa_3/instruction.md b/tasks/0001_893_1893246_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..406f397a713147c7850a74d5234c389ede09c93c --- /dev/null +++ b/tasks/0001_893_1893246_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): +- cereal.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 health rating metric (difference between maximum and minimum values) in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_893_1893246_qa_3/task.toml b/tasks/0001_893_1893246_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..acc8ce777424e02f7bcfa7397bf304b05863b723 --- /dev/null +++ b/tasks/0001_893_1893246_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_893_1893246_qa_3" +description = "What is the range of the health rating metric (difference between maximum and minimum values) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/893/1893246.ipynb_qa_3" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "75.662061" +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__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "75.662061" +QUESTION = "What is the range of the health rating metric (difference between maximum and minimum values) 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_902_1902242_qa_4/instruction.md b/tasks/0001_902_1902242_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f2f8240353961faa6e2ad18637707eafc6d45dbf --- /dev/null +++ b/tasks/0001_902_1902242_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- voice.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total number of samples in each class (male and female) in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as comma-separated : pairs, with the class label first. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_902_1902242_qa_4/task.toml b/tasks/0001_902_1902242_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b5f03dd0599aa7c4ff061bbc2ce9e83a97f0d5de --- /dev/null +++ b/tasks/0001_902_1902242_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_902_1902242_qa_4" +description = "What is the total number of samples in each class (male and female) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/902/1902242.ipynb_qa_4" +kaggle_dataset_name = "primaryobjects/voicegender" +gold_answer = "male: 1584, female: 1584" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "primaryobjects__voicegender" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "primaryobjects/voicegender" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "male: 1584, female: 1584" +QUESTION = "What is the total number of samples in each class (male and female) in the dataset?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_930_1930899_qa_1/instruction.md b/tasks/0001_930_1930899_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..07c4587411c5085e562d81f3048bd4a48cd666e7 --- /dev/null +++ b/tasks/0001_930_1930899_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): +- guns.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which racial group has the highest average age of victims in gun-related deaths according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_930_1930899_qa_1/task.toml b/tasks/0001_930_1930899_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0555a5133fe41c2f14084646debd7d0b26b60436 --- /dev/null +++ b/tasks/0001_930_1930899_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_930_1930899_qa_1" +description = "Which racial group has the highest average age of victims in gun-related deaths according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/930/1930899.ipynb_qa_1" +kaggle_dataset_name = "hakabuk/gun-deaths-in-the-us" +gold_answer = "White" +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 = "hakabuk__gun-deaths-in-the-us" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hakabuk/gun-deaths-in-the-us" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "White" +QUESTION = "Which racial group has the highest average age of victims in gun-related deaths according to the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_935_1935106_qa_2/instruction.md b/tasks/0001_935_1935106_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0b9366b9e22845ae667967e3e2a65e9907a4c60b --- /dev/null +++ b/tasks/0001_935_1935106_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- nnDataSet.json + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which legislator received the highest total contributions, and what was the amount? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, name first, amount as a plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_935_1935106_qa_2/task.toml b/tasks/0001_935_1935106_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..54a4357a81e7015c067255f8732558d18d232a9f --- /dev/null +++ b/tasks/0001_935_1935106_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_935_1935106_qa_2" +description = "Which legislator received the highest total contributions, and what was the amount?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/935/1935106.ipynb_qa_2" +kaggle_dataset_name = "theriley106/net-neutrality-accountability" +gold_answer = "John McCain, 2554784" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "theriley106__net-neutrality-accountability" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "theriley106/net-neutrality-accountability" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "John McCain, 2554784" +QUESTION = "Which legislator received the highest total contributions, and what was the amount?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_937_1937476_qa_2/instruction.md b/tasks/0001_937_1937476_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0ced3f65b66d4668ee36fa588497cb42ea56fedb --- /dev/null +++ b/tasks/0001_937_1937476_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winemag-data_first150k.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average price of wines from Australia as shown in the groupby mean 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/0001_937_1937476_qa_2/task.toml b/tasks/0001_937_1937476_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2a9275345e8122bf58a67cdbca2a4affe4c14718 --- /dev/null +++ b/tasks/0001_937_1937476_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_937_1937476_qa_2" +description = "What is the average price of wines from Australia as shown in the groupby mean output?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/937/1937476.ipynb_qa_2" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "31.258480" +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 = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "31.258480" +QUESTION = "What is the average price of wines from Australia as shown in the groupby mean output?" +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_956_1956536_qa_4/instruction.md b/tasks/0001_956_1956536_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d3823ed286ec73d79e2cf3fa8708963c390efd59 --- /dev/null +++ b/tasks/0001_956_1956536_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which job role has the lowest median job satisfaction according to the box plots? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_956_1956536_qa_4/task.toml b/tasks/0001_956_1956536_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dd005c4e7ad2850d544ccf14acd67f5f4a1f402c --- /dev/null +++ b/tasks/0001_956_1956536_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_956_1956536_qa_4" +description = "Which job role has the lowest median job satisfaction according to the box plots?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/956/1956536.ipynb_qa_4" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "Human Resources" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Human Resources" +QUESTION = "Which job role has the lowest median job satisfaction according to the box plots?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0001_969_1969476_qa_2/instruction.md b/tasks/0001_969_1969476_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..43368fedaf477bd5c079be44c4e7591ea5c499bf --- /dev/null +++ b/tasks/0001_969_1969476_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): +- Health_AnimalBites.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many dog bite records in the dataset resulted in a confirmed rabies case after filtering out records with unknown outcomes? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_969_1969476_qa_2/task.toml b/tasks/0001_969_1969476_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ca3136615af6a3170f2d1186714b1fa764684725 --- /dev/null +++ b/tasks/0001_969_1969476_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_969_1969476_qa_2" +description = "How many dog bite records in the dataset resulted in a confirmed rabies case after filtering out records with unknown outcomes?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/969/1969476.ipynb_qa_2" +kaggle_dataset_name = "rtatman/animal-bites" +gold_answer = "1" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rtatman__animal-bites" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rtatman/animal-bites" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "How many dog bite records in the dataset resulted in a confirmed rabies case after filtering out records with unknown outcomes?" +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_969_1969476_qa_3/instruction.md b/tasks/0001_969_1969476_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f4a291703c29a5490e59d68ce9f12e25611912c4 --- /dev/null +++ b/tasks/0001_969_1969476_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): +- Health_AnimalBites.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the original dataset consists of dog bite records (excluding cat bites and other species)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_969_1969476_qa_3/task.toml b/tasks/0001_969_1969476_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2596ed0d22875d742971abfb9c7ee6b0cf139b14 --- /dev/null +++ b/tasks/0001_969_1969476_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0001_969_1969476_qa_3" +description = "What percentage of the original dataset consists of dog bite records (excluding cat bites and other species)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/969/1969476.ipynb_qa_3" +kaggle_dataset_name = "rtatman/animal-bites" +gold_answer = "78.07" +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 = "rtatman__animal-bites" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rtatman/animal-bites" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "78.07" +QUESTION = "What percentage of the original dataset consists of dog bite records (excluding cat bites and other species)?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0002_081_2081941_qa_2/instruction.md b/tasks/0002_081_2081941_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..804a5e8dee35c8f285bb3b951101fa07d94d00c6 --- /dev/null +++ b/tasks/0002_081_2081941_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): +- ted_main.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which variable has the strongest positive correlation with the number of views in the TED talks 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_081_2081941_qa_2/task.toml b/tasks/0002_081_2081941_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2a39446cd690b152089279ef2de1e391324900ed --- /dev/null +++ b/tasks/0002_081_2081941_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0002_081_2081941_qa_2" +description = "Which variable has the strongest positive correlation with the number of views in the TED talks dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/081/2081941.ipynb_qa_2" +kaggle_dataset_name = "rounakbanik/ted-talks" +gold_answer = "comments" +reward_mode_initial = "exact_short" +package_tier = 3 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rounakbanik__ted-talks" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rounakbanik/ted-talks" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "comments" +QUESTION = "Which variable has the strongest positive correlation with the number of views in the TED talks 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_092_2092240_qa_1/instruction.md b/tasks/0002_092_2092240_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b9ae0739a8c43e075a6dc07455154b9d3d658d95 --- /dev/null +++ b/tasks/0002_092_2092240_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median number of axillary nodes detected for patients who survived more than 5 years? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0002_092_2092240_qa_1/task.toml b/tasks/0002_092_2092240_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a6af1d15c0047805719df45c2befdbcb1bf6eb5f --- /dev/null +++ b/tasks/0002_092_2092240_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0002_092_2092240_qa_1" +description = "What is the median number of axillary nodes detected for patients who survived more than 5 years?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/092/2092240.ipynb_qa_1" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "What is the median number of axillary nodes detected for patients who survived more than 5 years?" +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_217_2217508_qa_3/instruction.md b/tasks/0002_217_2217508_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..977a03647b1daf7b29672d7280904de6c2ec0ab3 --- /dev/null +++ b/tasks/0002_217_2217508_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average Total stat of all Pokémon in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0002_217_2217508_qa_3/task.toml b/tasks/0002_217_2217508_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..75c5d610bc87736661114d67d3a876eb779c6d12 --- /dev/null +++ b/tasks/0002_217_2217508_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0002_217_2217508_qa_3" +description = "What is the average Total stat of all Pokémon in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/217/2217508.ipynb_qa_3" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "435.1025" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "435.1025" +QUESTION = "What is the average Total stat of all Pokémon 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/0002_217_2217977_qa_1/instruction.md b/tasks/0002_217_2217977_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b29ae5cbff8248b422dd25ffaae9e2e1a59f3a0f --- /dev/null +++ b/tasks/0002_217_2217977_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winemag-data_first150k.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many wines in the original dataset have missing price 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/0002_217_2217977_qa_1/task.toml b/tasks/0002_217_2217977_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e5725cb136fed8c392b56f5e0d8728faed5ec150 --- /dev/null +++ b/tasks/0002_217_2217977_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0002_217_2217977_qa_1" +description = "How many wines in the original dataset have missing price values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0002/217/2217977.ipynb_qa_1" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "13695" +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 = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "13695" +QUESTION = "How many wines in the original dataset have missing price 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/0010_489_10489077_qa_4/instruction.md b/tasks/0010_489_10489077_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4b2ac520860d1372e7b16873946c09fce537b9b9 --- /dev/null +++ b/tasks/0010_489_10489077_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- 2015.csv +- 2016.csv +- 2017.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference in the number of countries between 2015 and 2017 datasets? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0010_489_10489077_qa_4/task.toml b/tasks/0010_489_10489077_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..49cb4505afce4dcdcc0342955c5d1bed94fd48e2 --- /dev/null +++ b/tasks/0010_489_10489077_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0010_489_10489077_qa_4" +description = "What is the difference in the number of countries between 2015 and 2017 datasets?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0010/489/10489077.ipynb_qa_4" +kaggle_dataset_name = "unsdsn/world-happiness" +gold_answer = "3" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "unsdsn__world-happiness" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "unsdsn/world-happiness" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "What is the difference in the number of countries between 2015 and 2017 datasets?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0011_355_11355842_qa_3/instruction.md b/tasks/0011_355_11355842_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..aa2ec513b9543c8924a8f69620a5d319294593f1 --- /dev/null +++ b/tasks/0011_355_11355842_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): +- column_2C_weka.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset has the highest standard deviation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_355_11355842_qa_3/task.toml b/tasks/0011_355_11355842_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c838441288a873cf8f4e172aa9f426c2aab7da41 --- /dev/null +++ b/tasks/0011_355_11355842_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0011_355_11355842_qa_3" +description = "Which feature in the dataset has the highest standard deviation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/355/11355842.ipynb_qa_3" +kaggle_dataset_name = "uciml/biomechanical-features-of-orthopedic-patients" +gold_answer = "degree_spondylolisthesis" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__biomechanical-features-of-orthopedic-patients" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/biomechanical-features-of-orthopedic-patients" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "degree_spondylolisthesis" +QUESTION = "Which feature in the dataset has the highest standard deviation?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0011_763_11763257_qa_2/instruction.md b/tasks/0011_763_11763257_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4567be804aec55304db4d4b8411323f2f14642a4 --- /dev/null +++ b/tasks/0011_763_11763257_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 categorical variables are present in the original dataset before any transformations? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0011_763_11763257_qa_2/task.toml b/tasks/0011_763_11763257_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cbf29a050d38c36f8f056dacf8ce9986c793b15c --- /dev/null +++ b/tasks/0011_763_11763257_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0011_763_11763257_qa_2" +description = "How many categorical variables are present in the original dataset before any transformations?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/763/11763257.ipynb_qa_2" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "9" +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 = "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 = "9" +QUESTION = "How many categorical variables are present in the original dataset before any transformations?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0011_763_11763257_qa_4/instruction.md b/tasks/0011_763_11763257_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..53353d1f21f55cd46b8b888dc183252492c3c0cd --- /dev/null +++ b/tasks/0011_763_11763257_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which column in the dataset is identified as having no analytical value due to its constant value across all records? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_763_11763257_qa_4/task.toml b/tasks/0011_763_11763257_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4e1464eb9cf1a96f68d57092f7035ba07adace81 --- /dev/null +++ b/tasks/0011_763_11763257_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0011_763_11763257_qa_4" +description = "Which column in the dataset is identified as having no analytical value due to its constant value across all records?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/763/11763257.ipynb_qa_4" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "EmployeeCount" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "EmployeeCount" +QUESTION = "Which column in the dataset is identified as having no analytical value due to its constant value across all records?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0012_101_12101308_qa_2/instruction.md b/tasks/0012_101_12101308_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2abc72cdbb07e42a292d5710482de226bca5d887 --- /dev/null +++ b/tasks/0012_101_12101308_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which department has the highest attrition rate according to 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/0012_101_12101308_qa_2/task.toml b/tasks/0012_101_12101308_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..25afaea6136bb15fa3ef311bde7eb07d3c26c953 --- /dev/null +++ b/tasks/0012_101_12101308_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0012_101_12101308_qa_2" +description = "Which department has the highest attrition rate according to the analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0012/101/12101308.ipynb_qa_2" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "Sales" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Sales" +QUESTION = "Which department has the highest attrition rate according to the 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/0012_112_12112066_qa_4/instruction.md b/tasks/0012_112_12112066_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0e93d375b6e2b35eec3871d47a463f357ea7a66c --- /dev/null +++ b/tasks/0012_112_12112066_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- pokemon.csv +- tests.csv +- combats.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which non-legendary Pokémon has the highest HP value in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0012_112_12112066_qa_4/task.toml b/tasks/0012_112_12112066_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4f8396144f6de514016e9d6fa60e1ffda1bbd2d9 --- /dev/null +++ b/tasks/0012_112_12112066_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0012_112_12112066_qa_4" +description = "Which non-legendary Pokémon has the highest HP value in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0012/112/12112066.ipynb_qa_4" +kaggle_dataset_name = "terminus7/pokemon-challenge" +gold_answer = "Blissey" +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 = "terminus7__pokemon-challenge" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Blissey" +QUESTION = "Which non-legendary Pokémon has the highest HP value in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0012_330_12330544_qa_3/instruction.md b/tasks/0012_330_12330544_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e1015517b5f82e606deb0cdb0646724541822cd8 --- /dev/null +++ b/tasks/0012_330_12330544_qa_3/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Are the classes uniformly distributed in the training dataset based on the provided 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/0012_330_12330544_qa_3/task.toml b/tasks/0012_330_12330544_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b3af49cafce0fcab69c99bffac3647065457decf --- /dev/null +++ b/tasks/0012_330_12330544_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0012_330_12330544_qa_3" +description = "Are the classes uniformly distributed in the training dataset based on the provided analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0012/330/12330544.ipynb_qa_3" +kaggle_dataset_name = "uciml/human-activity-recognition-with-smartphones" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 2 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__human-activity-recognition-with-smartphones" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/human-activity-recognition-with-smartphones" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Are the classes uniformly distributed in the training dataset based on the provided analysis?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0012_840_12840531_qa_5/instruction.md b/tasks/0012_840_12840531_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f7bff1ddd30585bd8732d43ab72588ada5a4cce1 --- /dev/null +++ b/tasks/0012_840_12840531_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): +- sign_mnist_train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After normalization, what is the range of pixel intensity values in the training data? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0012_840_12840531_qa_5/task.toml b/tasks/0012_840_12840531_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..15ff776bd4d0f80d3a6d9570826f67e308c9e813 --- /dev/null +++ b/tasks/0012_840_12840531_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0012_840_12840531_qa_5" +description = "After normalization, what is the range of pixel intensity values in the training data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0012/840/12840531.ipynb_qa_5" +kaggle_dataset_name = "datamunge/sign-language-mnist" +gold_answer = "0 to 1" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "datamunge__sign-language-mnist" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datamunge/sign-language-mnist" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0 to 1" +QUESTION = "After normalization, what is the range of pixel intensity values in the training data?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0013_457_13457318_qa_3/instruction.md b/tasks/0013_457_13457318_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..86a3557154951024a941dc8897d7223df20a7da6 --- /dev/null +++ b/tasks/0013_457_13457318_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- german_credit_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which loan purpose category has the highest number of "good" risk credit holders among female applicants? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0013_457_13457318_qa_3/task.toml b/tasks/0013_457_13457318_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a7cb8ef6d64065a8016a595d3379af2f7f9ca42c --- /dev/null +++ b/tasks/0013_457_13457318_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0013_457_13457318_qa_3" +description = "Which loan purpose category has the highest number of \"good\" risk credit holders among female applicants?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/457/13457318.ipynb_qa_3" +kaggle_dataset_name = "kabure/german-credit-data-with-risk" +gold_answer = "radio/TV" +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 = "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 = "radio/TV" +QUESTION = "Which loan purpose category has the highest number of \"good\" risk credit holders among female applicants?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0013_821_13821679_qa_4/instruction.md b/tasks/0013_821_13821679_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7bae9c6dc1def109ea9fac12911078a352463136 --- /dev/null +++ b/tasks/0013_821_13821679_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many non-legendary Pokémon have both Type 1 as Water and Type 2 as Flying? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0013_821_13821679_qa_4/task.toml b/tasks/0013_821_13821679_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6333d35ef000dc27176f2da8fb87a830cdd7f940 --- /dev/null +++ b/tasks/0013_821_13821679_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0013_821_13821679_qa_4" +description = "How many non-legendary Pokémon have both Type 1 as Water and Type 2 as Flying?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0013/821/13821679.ipynb_qa_4" +kaggle_dataset_name = "terminus7/pokemon-challenge" +gold_answer = "7" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "terminus7__pokemon-challenge" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "terminus7/pokemon-challenge" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7" +QUESTION = "How many non-legendary Pokémon have both Type 1 as Water and Type 2 as Flying?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0014_115_14115737_qa_1/instruction.md b/tasks/0014_115_14115737_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b1ba1d1a8eac4f70dbf0e6cd7a4029be3eacfd40 --- /dev/null +++ b/tasks/0014_115_14115737_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest global sales value recorded for any video game in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0014_115_14115737_qa_1/task.toml b/tasks/0014_115_14115737_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..450d8ac7e6fb87abe8997cb1c4bf7c8e3bacbd94 --- /dev/null +++ b/tasks/0014_115_14115737_qa_1/task.toml @@ -0,0 +1,58 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0014_115_14115737_qa_1" +description = "What is the highest global sales value recorded for any video game in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/115/14115737.ipynb_qa_1" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "82.74" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 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 = "82.74" +QUESTION = "What is the highest global sales value recorded for any video game in the dataset?" +REWARD_MODE = "numeric" + +[agent] +timeout_sec = 900.0 + +[solution.env] diff --git a/tasks/0014_358_14358635_qa_1/instruction.md b/tasks/0014_358_14358635_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..959d017a8e510902383e728dedacd591b6486ba9 --- /dev/null +++ b/tasks/0014_358_14358635_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the highest Pearson correlation coefficient with median house value after creating the rooms_per_household derived 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/0014_358_14358635_qa_1/task.toml b/tasks/0014_358_14358635_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5335177764da559b135a672a93c492ecf313399c --- /dev/null +++ b/tasks/0014_358_14358635_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0014_358_14358635_qa_1" +description = "Which feature has the highest Pearson correlation coefficient with median house value after creating the rooms_per_household derived feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0014/358/14358635.ipynb_qa_1" +kaggle_dataset_name = "camnugent/california-housing-prices" +gold_answer = "median_income" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "camnugent__california-housing-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "camnugent/california-housing-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "median_income" +QUESTION = "Which feature has the highest Pearson correlation coefficient with median house value after creating the rooms_per_household derived feature?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0015_157_15157151_qa_5/instruction.md b/tasks/0015_157_15157151_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6ca38e0f121cf0976a1a9d920305721f57c8c9de --- /dev/null +++ b/tasks/0015_157_15157151_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): +- Hospitals.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many districts have zero First Referral Units (FRUs) as calculated by summing Community Health Centres, Area Hospitals, and District Hospitals? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0015_157_15157151_qa_5/task.toml b/tasks/0015_157_15157151_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ad50fb7a2359d725f5019c0bcafecd2bfc8a01b3 --- /dev/null +++ b/tasks/0015_157_15157151_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0015_157_15157151_qa_5" +description = "How many districts have zero First Referral Units (FRUs) as calculated by summing Community Health Centres, Area Hospitals, and District Hospitals?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0015/157/15157151.ipynb_qa_5" +kaggle_dataset_name = "sumendar/telangana-hospitals" +gold_answer = "1" +reward_mode_initial = "numeric" +package_tier = 3 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "sumendar__telangana-hospitals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sumendar/telangana-hospitals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "How many districts have zero First Referral Units (FRUs) as calculated by summing Community Health Centres, Area Hospitals, and District Hospitals?" +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/0015_211_15211665_qa_1/instruction.md b/tasks/0015_211_15211665_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2b96649ad0223d421051a32417c55c70426178c6 --- /dev/null +++ b/tasks/0015_211_15211665_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many categories were present in the 'ocean_proximity' column after applying one-hot encoding to the housing dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0015_211_15211665_qa_1/task.toml b/tasks/0015_211_15211665_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9572c34c995b226170f27b632f9f5f7784b44538 --- /dev/null +++ b/tasks/0015_211_15211665_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0015_211_15211665_qa_1" +description = "How many categories were present in the 'ocean_proximity' column after applying one-hot encoding to the housing dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0015/211/15211665.ipynb_qa_1" +kaggle_dataset_name = "anuvrat29/california-housing-value" +gold_answer = "5" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "anuvrat29__california-housing-value" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "anuvrat29/california-housing-value" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5" +QUESTION = "How many categories were present in the 'ocean_proximity' column after applying one-hot encoding to the housing 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/0015_808_15808353_qa_1/instruction.md b/tasks/0015_808_15808353_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f2e794c8d2f7836358caeea5ac7c435138bd66a5 --- /dev/null +++ b/tasks/0015_808_15808353_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of patients in the Haberman dataset who survived after 5 years (Surv_status = "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/0015_808_15808353_qa_1/task.toml b/tasks/0015_808_15808353_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..878acb4a006a9354b808fbd9a95e589f211c98eb --- /dev/null +++ b/tasks/0015_808_15808353_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0015_808_15808353_qa_1" +description = "What is the percentage of patients in the Haberman dataset who survived after 5 years (Surv_status = \"yes\")?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0015/808/15808353.ipynb_qa_1" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "73.44" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "73.44" +QUESTION = "What is the percentage of patients in the Haberman dataset who survived after 5 years (Surv_status = \"yes\")?" +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/0015_861_15861774_qa_1/instruction.md b/tasks/0015_861_15861774_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b119f33689463bcf3c88f20642115f0f37ccee6b --- /dev/null +++ b/tasks/0015_861_15861774_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): +- Airplane_Crashes_and_Fatalities_Since_1908.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which year had the highest total number of fatalities in aviation history 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/0015_861_15861774_qa_1/task.toml b/tasks/0015_861_15861774_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..62bf9979cdf91ea066f83a6cddd6dc56fb991d26 --- /dev/null +++ b/tasks/0015_861_15861774_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0015_861_15861774_qa_1" +description = "Which year had the highest total number of fatalities in aviation history according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0015/861/15861774.ipynb_qa_1" +kaggle_dataset_name = "saurograndi/airplane-crashes-since-1908" +gold_answer = "1972" +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 = "saurograndi__airplane-crashes-since-1908" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "saurograndi/airplane-crashes-since-1908" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1972" +QUESTION = "Which year had the highest total number of fatalities in aviation history according to 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/0015_881_15881525_qa_2/instruction.md b/tasks/0015_881_15881525_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1ea31a495f5db36cddc617d691cba1e09af73c65 --- /dev/null +++ b/tasks/0015_881_15881525_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- covtype.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent cover type in the dataset, and how many instances does it contain? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, label first, keep the exact count as a plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0015_881_15881525_qa_2/task.toml b/tasks/0015_881_15881525_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e7c6da5fb5aa59dcd11c8d28ab81653cc8957c5a --- /dev/null +++ b/tasks/0015_881_15881525_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0015_881_15881525_qa_2" +description = "What is the most frequent cover type in the dataset, and how many instances does it contain?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0015/881/15881525.ipynb_qa_2" +kaggle_dataset_name = "uciml/forest-cover-type-dataset" +gold_answer = "Cover_Type 2, 283301" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__forest-cover-type-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/forest-cover-type-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Cover_Type 2, 283301" +QUESTION = "What is the most frequent cover type in the dataset, and how many instances does it contain?" +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/0017_703_17703063_qa_2/instruction.md b/tasks/0017_703_17703063_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d8a4ab64f6f76467e526cfe256bfb472167f3918 --- /dev/null +++ b/tasks/0017_703_17703063_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 state has the lowest per hectare cost for sugarcane according to the cultivation_data? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0017_703_17703063_qa_2/task.toml b/tasks/0017_703_17703063_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..372fa4c3c47408e5bf6f726cdc782621789a802b --- /dev/null +++ b/tasks/0017_703_17703063_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0017_703_17703063_qa_2" +description = "Which state has the lowest per hectare cost for sugarcane according to the cultivation_data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/703/17703063.ipynb_qa_2" +kaggle_dataset_name = "srinivas1/agricuture-crops-production-in-india" +gold_answer = "Uttar Pradesh" +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 = "srinivas1__agricuture-crops-production-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "srinivas1/agricuture-crops-production-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Uttar Pradesh" +QUESTION = "Which state has the lowest per hectare cost for sugarcane according to the cultivation_data?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0017_914_17914820_qa_1/instruction.md b/tasks/0017_914_17914820_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e465bdfd2cd66e870554ae8c3ea66b04645b9898 --- /dev/null +++ b/tasks/0017_914_17914820_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- amazon_jobs_dataset.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which month in the year 2018 had the highest number of Amazon job openings, and how many openings were there? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, month first, count as a plain number). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0017_914_17914820_qa_1/task.toml b/tasks/0017_914_17914820_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..98c9406b6080c4235f645d9239ffd6021acd9be6 --- /dev/null +++ b/tasks/0017_914_17914820_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0017_914_17914820_qa_1" +description = "Which month in the year 2018 had the highest number of Amazon job openings, and how many openings were there?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0017/914/17914820.ipynb_qa_1" +kaggle_dataset_name = "atahmasb/amazon-job-skills" +gold_answer = "January, 907" +reward_mode_initial = "list" +package_tier = 3 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "atahmasb__amazon-job-skills" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "atahmasb/amazon-job-skills" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "January, 907" +QUESTION = "Which month in the year 2018 had the highest number of Amazon job openings, and how many openings were there?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0019_416_19416448_qa_4/instruction.md b/tasks/0019_416_19416448_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3d9c78d2ddea44fa22e0c05c2d470950cdc66b12 --- /dev/null +++ b/tasks/0019_416_19416448_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): +- CandidateSummaryAction1.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the precision score for predicting candidates who did not win (class 0.0) in the test data? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0019_416_19416448_qa_4/task.toml b/tasks/0019_416_19416448_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..50f7c4e3f493ae0cc5fee202643635cbfa72a144 --- /dev/null +++ b/tasks/0019_416_19416448_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0019_416_19416448_qa_4" +description = "What is the precision score for predicting candidates who did not win (class 0.0) in the test data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0019/416/19416448.ipynb_qa_4" +kaggle_dataset_name = "danerbland/electionfinance" +gold_answer = "0.92" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "danerbland__electionfinance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "danerbland/electionfinance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.92" +QUESTION = "What is the precision score for predicting candidates who did not win (class 0.0) in the test data?" +REWARD_MODE = "flexible" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0019_521_19521236_qa_1/instruction.md b/tasks/0019_521_19521236_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0fbb38a830b128d7c0c596891f8d6d82a0422af6 --- /dev/null +++ b/tasks/0019_521_19521236_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- menu.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which menu item has the highest calorie count 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/0019_521_19521236_qa_1/task.toml b/tasks/0019_521_19521236_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d8db43f99102cc64851feb6ca3430bf5e6b8479d --- /dev/null +++ b/tasks/0019_521_19521236_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0019_521_19521236_qa_1" +description = "Which menu item has the highest calorie count according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0019/521/19521236.ipynb_qa_1" +kaggle_dataset_name = "mcdonalds/nutrition-facts" +gold_answer = "Chicken McNuggets (40 piece)" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mcdonalds__nutrition-facts" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mcdonalds/nutrition-facts" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Chicken McNuggets (40 piece)" +QUESTION = "Which menu item has the highest calorie count 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/0020_395_20395932_qa_4/instruction.md b/tasks/0020_395_20395932_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a505b2d481761e2c878117b36752295b07db0f79 --- /dev/null +++ b/tasks/0020_395_20395932_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the number of ham messages significantly higher than spam messages in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0020_395_20395932_qa_4/task.toml b/tasks/0020_395_20395932_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b6b36bfeb376b9dfafc19634cb011dd20910d65c --- /dev/null +++ b/tasks/0020_395_20395932_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0020_395_20395932_qa_4" +description = "Is the number of ham messages significantly higher than spam messages in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/395/20395932.ipynb_qa_4" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__sms-spam-collection-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the number of ham messages significantly higher than spam messages in the dataset?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0020_511_20511877_qa_4/instruction.md b/tasks/0020_511_20511877_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7ce0c49322d05b93da16fec701af9bd4a898276b --- /dev/null +++ b/tasks/0020_511_20511877_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): +- Video_Games_Sales_as_at_22_Dec_2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest NA_Sales value among games released after 2010 with global sales over 12 million? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_511_20511877_qa_4/task.toml b/tasks/0020_511_20511877_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e873732bd88f881f55a18c6861192a472f3729e4 --- /dev/null +++ b/tasks/0020_511_20511877_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0020_511_20511877_qa_4" +description = "What is the highest NA_Sales value among games released after 2010 with global sales over 12 million?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/511/20511877.ipynb_qa_4" +kaggle_dataset_name = "rush4ratio/video-game-sales-with-ratings" +gold_answer = "9.66" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "9.66" +QUESTION = "What is the highest NA_Sales value among games released after 2010 with global sales over 12 million?" +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/0020_895_20895805_qa_2/instruction.md b/tasks/0020_895_20895805_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..282dc5663eeec9aba1e8235b06f0a7af98b49def --- /dev/null +++ b/tasks/0020_895_20895805_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): +- Tweets.csv +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of tweets have a valid negative reason recorded after data preprocessing? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0020_895_20895805_qa_2/task.toml b/tasks/0020_895_20895805_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a319759073ad87f69996046eb27577a0d5c93e55 --- /dev/null +++ b/tasks/0020_895_20895805_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0020_895_20895805_qa_2" +description = "What percentage of tweets have a valid negative reason recorded after data preprocessing?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0020/895/20895805.ipynb_qa_2" +kaggle_dataset_name = "crowdflower/twitter-airline-sentiment" +gold_answer = "63.12" +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 = "crowdflower__twitter-airline-sentiment" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crowdflower/twitter-airline-sentiment" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "63.12" +QUESTION = "What percentage of tweets have a valid negative reason recorded after data preprocessing?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0021_145_21145195_qa_3/instruction.md b/tasks/0021_145_21145195_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c93295a6e9585c769fa2dc4acf3c73a89e35bab7 --- /dev/null +++ b/tasks/0021_145_21145195_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): +- rainfall in india 1901-2015.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which month has the highest average rainfall in the Western Ghats across all subdivisions? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as the month name only. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_145_21145195_qa_3/task.toml b/tasks/0021_145_21145195_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9a6f48010e773968a890c384049b8b2d87d526a9 --- /dev/null +++ b/tasks/0021_145_21145195_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0021_145_21145195_qa_3" +description = "Which month has the highest average rainfall in the Western Ghats across all subdivisions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/145/21145195.ipynb_qa_3" +kaggle_dataset_name = "rajanand/rainfall-in-india" +gold_answer = "July" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rajanand__rainfall-in-india" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rajanand/rainfall-in-india" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "July" +QUESTION = "Which month has the highest average rainfall in the Western Ghats across all subdivisions?" +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_336_21336465_qa_2/instruction.md b/tasks/0021_336_21336465_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2f68316af498653295c6ebb80249cd5483620417 --- /dev/null +++ b/tasks/0021_336_21336465_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the dataset was removed due to missing TotalCharges values? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0021_336_21336465_qa_2/task.toml b/tasks/0021_336_21336465_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..59938e9b5eb940d6b6e9ba2cd6f455d4aafe73d7 --- /dev/null +++ b/tasks/0021_336_21336465_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0021_336_21336465_qa_2" +description = "What percentage of the dataset was removed due to missing TotalCharges values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/336/21336465.ipynb_qa_2" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "0.16" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.16" +QUESTION = "What percentage of the dataset was removed due to missing TotalCharges values?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0021_847_21847371_qa_3/instruction.md b/tasks/0021_847_21847371_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..abf498e0249de5487c85bca2776e8e66202d679b --- /dev/null +++ b/tasks/0021_847_21847371_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): +- Tweets.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which sentiment category is most frequently represented in the training-validation split of the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0021_847_21847371_qa_3/task.toml b/tasks/0021_847_21847371_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..caa2643c6386c9d196f2b5c6f4e539bc3f76d94f --- /dev/null +++ b/tasks/0021_847_21847371_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0021_847_21847371_qa_3" +description = "Which sentiment category is most frequently represented in the training-validation split of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/847/21847371.ipynb_qa_3" +kaggle_dataset_name = "crowdflower/twitter-airline-sentiment" +gold_answer = "negative" +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 = "crowdflower__twitter-airline-sentiment" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crowdflower/twitter-airline-sentiment" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "negative" +QUESTION = "Which sentiment category is most frequently represented in the training-validation split of 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/0021_873_21873405_qa_2/instruction.md b/tasks/0021_873_21873405_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f46915411c133754ba530d1b09b3214618ecf00d --- /dev/null +++ b/tasks/0021_873_21873405_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean monthly charge for customers in the tenure-0-10 group who churned? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0021_873_21873405_qa_2/task.toml b/tasks/0021_873_21873405_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1259d469a3777cae0edaee030a6a623180746b45 --- /dev/null +++ b/tasks/0021_873_21873405_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0021_873_21873405_qa_2" +description = "What is the mean monthly charge for customers in the tenure-0-10 group who churned?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/873/21873405.ipynb_qa_2" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "65.86" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "65.86" +QUESTION = "What is the mean monthly charge for customers in the tenure-0-10 group who churned?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0023_531_23531492_qa_4/instruction.md b/tasks/0023_531_23531492_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5bdc422cd25537d1424106bcb81c55e92ea1fc05 --- /dev/null +++ b/tasks/0023_531_23531492_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean value of the 'Sp. Def' stat for all Pokémon in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_531_23531492_qa_4/task.toml b/tasks/0023_531_23531492_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..64d528a93ead7d4287abf6f911d2e7a488ecc74f --- /dev/null +++ b/tasks/0023_531_23531492_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0023_531_23531492_qa_4" +description = "What is the mean value of the 'Sp. Def' stat for all Pokémon in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/531/23531492.ipynb_qa_4" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "71.9025" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "71.9025" +QUESTION = "What is the mean value of the 'Sp. Def' stat for all Pokémon 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/0023_531_23531492_qa_5/instruction.md b/tasks/0023_531_23531492_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..05d3a352ea7291b9ba6beb11cf9a2e5ab87935e9 --- /dev/null +++ b/tasks/0023_531_23531492_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Pokemon.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the exact correlation coefficient between the 'Legendary' status and HP 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_531_23531492_qa_5/task.toml b/tasks/0023_531_23531492_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b3ee93daf471f3b168bf89fd783e46701e2f0d19 --- /dev/null +++ b/tasks/0023_531_23531492_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0023_531_23531492_qa_5" +description = "What is the exact correlation coefficient between the 'Legendary' status and HP in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/531/23531492.ipynb_qa_5" +kaggle_dataset_name = "abcsds/pokemon" +gold_answer = "0.2736" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "abcsds__pokemon" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "abcsds/pokemon" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.2736" +QUESTION = "What is the exact correlation coefficient between the 'Legendary' status and HP 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/0023_913_23913406_qa_1/instruction.md b/tasks/0023_913_23913406_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4e6c4ef37bdd8e2c95cf2f5a0b43f973b842c950 --- /dev/null +++ b/tasks/0023_913_23913406_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): +- credit_train.csv +- credit_test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many instances remain in the dataset after removing all rows with missing values? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0023_913_23913406_qa_1/task.toml b/tasks/0023_913_23913406_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e639ce2a1fbb66da97344316f215e244ed717148 --- /dev/null +++ b/tasks/0023_913_23913406_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0023_913_23913406_qa_1" +description = "How many instances remain in the dataset after removing all rows with missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0023/913/23913406.ipynb_qa_1" +kaggle_dataset_name = "zaurbegiev/my-dataset" +gold_answer = "36423" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zaurbegiev__my-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zaurbegiev/my-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "36423" +QUESTION = "How many instances remain in the dataset after removing all rows with missing values?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0024_252_24252070_qa_2/instruction.md b/tasks/0024_252_24252070_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d949a1c6b0c00281bf640341269fa9f86d855b67 --- /dev/null +++ b/tasks/0024_252_24252070_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): +- tmdb_5000_credits.csv +- tmdb_5000_movies.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many of the top 5 movie recommendations for "Fast Five" are identical between the two content-based filtering methods (Method 1 and Method 2)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0024_252_24252070_qa_2/task.toml b/tasks/0024_252_24252070_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ab0ff0d80c53a266268e0b83276af789bf20e37b --- /dev/null +++ b/tasks/0024_252_24252070_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0024_252_24252070_qa_2" +description = "How many of the top 5 movie recommendations for \"Fast Five\" are identical between the two content-based filtering methods (Method 1 and Method 2)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/252/24252070.ipynb_qa_2" +kaggle_dataset_name = "tmdb/tmdb-movie-metadata" +gold_answer = "1" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "tmdb__tmdb-movie-metadata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "How many of the top 5 movie recommendations for \"Fast Five\" are identical between the two content-based filtering methods (Method 1 and Method 2)?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0024_654_24654257_qa_2/instruction.md b/tasks/0024_654_24654257_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..82ad8532c158791ce33ff9657b3915178ff72a2c --- /dev/null +++ b/tasks/0024_654_24654257_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): +- Churn_Modelling.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the median age of customers who exited higher than those who did not exit? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_654_24654257_qa_2/task.toml b/tasks/0024_654_24654257_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..38a685733ca274e71e6641dd466993b29a3df9d5 --- /dev/null +++ b/tasks/0024_654_24654257_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0024_654_24654257_qa_2" +description = "Is the median age of customers who exited higher than those who did not exit?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/654/24654257.ipynb_qa_2" +kaggle_dataset_name = "filippoo/deep-learning-az-ann" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "filippoo__deep-learning-az-ann" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "filippoo/deep-learning-az-ann" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the median age of customers who exited higher than those who did not exit?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0024_893_24893903_qa_4/instruction.md b/tasks/0024_893_24893903_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f74b4b70b92e4539c142873fd9f9fdd2cb24f674 --- /dev/null +++ b/tasks/0024_893_24893903_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference in average years at company between employees who stayed and those who left the company? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0024_893_24893903_qa_4/task.toml b/tasks/0024_893_24893903_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..26edb15c128f9c1de23fd7eb46828558dfd12918 --- /dev/null +++ b/tasks/0024_893_24893903_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0024_893_24893903_qa_4" +description = "What is the difference in average years at company between employees who stayed and those who left the company?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0024/893/24893903.ipynb_qa_4" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "2.238" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2.238" +QUESTION = "What is the difference in average years at company between employees who stayed and those who left the company?" +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/0025_163_25163859_qa_4/instruction.md b/tasks/0025_163_25163859_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6fad5208facf4f93eb7e893d5997f7e24bc7f861 --- /dev/null +++ b/tasks/0025_163_25163859_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which specific months show the highest average number of passengers across all years in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the month names. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0025_163_25163859_qa_4/task.toml b/tasks/0025_163_25163859_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fe9f179ebf9f1b1714866760a731a47b62d0d075 --- /dev/null +++ b/tasks/0025_163_25163859_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0025_163_25163859_qa_4" +description = "Which specific months show the highest average number of passengers across all years in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0025/163/25163859.ipynb_qa_4" +kaggle_dataset_name = "rakannimer/air-passengers" +gold_answer = "July, August" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "rakannimer__air-passengers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rakannimer/air-passengers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "July, August" +QUESTION = "Which specific months show the highest average number of passengers across all years in the dataset?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0026_546_26546219_qa_3/instruction.md b/tasks/0026_546_26546219_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8977e9617ba755226a6ab402bb87cce42b1a2855 --- /dev/null +++ b/tasks/0026_546_26546219_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest price recorded for any house in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0026_546_26546219_qa_3/task.toml b/tasks/0026_546_26546219_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c1223a3a5e9793293c295b25d35a975459c15bae --- /dev/null +++ b/tasks/0026_546_26546219_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0026_546_26546219_qa_3" +description = "What is the highest price recorded for any house in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/546/26546219.ipynb_qa_3" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "7700000" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7700000" +QUESTION = "What is the highest price recorded for any house 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/0026_546_26546219_qa_5/instruction.md b/tasks/0026_546_26546219_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bd2332c04e17d75df3e242d45d177e20a95fbedb --- /dev/null +++ b/tasks/0026_546_26546219_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average number of bedrooms in the houses included in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0026_546_26546219_qa_5/task.toml b/tasks/0026_546_26546219_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4a4960179287664dd2a0bd162fd7e88a6d462bf8 --- /dev/null +++ b/tasks/0026_546_26546219_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0026_546_26546219_qa_5" +description = "What is the average number of bedrooms in the houses included in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/546/26546219.ipynb_qa_5" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "3.37" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3.37" +QUESTION = "What is the average number of bedrooms in the houses included in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0026_651_26651353_qa_3/instruction.md b/tasks/0026_651_26651353_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..75e964579d5b75ce44e3664b2aaf1dab67b77b98 --- /dev/null +++ b/tasks/0026_651_26651353_qa_3/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference in skewness between the original SalePrice distribution and its log-transformed distribution? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0026_651_26651353_qa_3/task.toml b/tasks/0026_651_26651353_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..af099f6e97a12e262ac2af341d09d41e018aef4d --- /dev/null +++ b/tasks/0026_651_26651353_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0026_651_26651353_qa_3" +description = "What is the difference in skewness between the original SalePrice distribution and its log-transformed distribution?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/651/26651353.ipynb_qa_3" +kaggle_dataset_name = "lespin/house-prices-dataset" +gold_answer = "1.759730" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "lespin__house-prices-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "lespin/house-prices-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.759730" +QUESTION = "What is the difference in skewness between the original SalePrice distribution and its log-transformed distribution?" +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/0027_089_27089896_qa_3/instruction.md b/tasks/0027_089_27089896_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b486a2573063ccf99cbd680cacacef60e66edec0 --- /dev/null +++ b/tasks/0027_089_27089896_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): +- USA_Housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the intercept value of the linear regression model after training? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0027_089_27089896_qa_3/task.toml b/tasks/0027_089_27089896_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e23a076f2556ca6d5c659e78f95490026b23f400 --- /dev/null +++ b/tasks/0027_089_27089896_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0027_089_27089896_qa_3" +description = "What is the intercept value of the linear regression model after training?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0027/089/27089896.ipynb_qa_3" +kaggle_dataset_name = "aariyan101/usa-housingcsv" +gold_answer = "-2640159.796853739" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "aariyan101__usa-housingcsv" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "aariyan101/usa-housingcsv" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "-2640159.796853739" +QUESTION = "What is the intercept value of the linear regression model after training?" +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/0027_151_27151900_qa_5/instruction.md b/tasks/0027_151_27151900_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..adaca509455ba78624640bb45b1bd4af98524e39 --- /dev/null +++ b/tasks/0027_151_27151900_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): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the F1 score of the Logistic Regression model on the training data? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0027_151_27151900_qa_5/task.toml b/tasks/0027_151_27151900_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2b17aeff3ec6791502390f7ba52474f78699e476 --- /dev/null +++ b/tasks/0027_151_27151900_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0027_151_27151900_qa_5" +description = "What is the F1 score of the Logistic Regression model on the training data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0027/151/27151900.ipynb_qa_5" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "0.94559" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.94559" +QUESTION = "What is the F1 score of the Logistic Regression model on the training data?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0027_246_27246299_qa_4/instruction.md b/tasks/0027_246_27246299_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b47eb962d915dbc639715e881805b19f36466c14 --- /dev/null +++ b/tasks/0027_246_27246299_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature in the dataset had the highest standard deviation before any data preprocessing steps? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0027_246_27246299_qa_4/task.toml b/tasks/0027_246_27246299_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..684262e73aeb291fab290804b3a52112d204c50a --- /dev/null +++ b/tasks/0027_246_27246299_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0027_246_27246299_qa_4" +description = "Which feature in the dataset had the highest standard deviation before any data preprocessing steps?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0027/246/27246299.ipynb_qa_4" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Insulin" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Insulin" +QUESTION = "Which feature in the dataset had the highest standard deviation before any data preprocessing steps?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0028_007_28007632_qa_3/instruction.md b/tasks/0028_007_28007632_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..337c5f14ee5ab2403591df0e99d62be24fb3eb45 --- /dev/null +++ b/tasks/0028_007_28007632_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Based on the violin plots, which feature exhibits the greatest separation in distributions between the three species? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0028_007_28007632_qa_3/task.toml b/tasks/0028_007_28007632_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7f302079b052d134c994a8e3e1ee27c509532c14 --- /dev/null +++ b/tasks/0028_007_28007632_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0028_007_28007632_qa_3" +description = "Based on the violin plots, which feature exhibits the greatest separation in distributions between the three species?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/007/28007632.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalLengthCm" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PetalLengthCm" +QUESTION = "Based on the violin plots, which feature exhibits the greatest separation in distributions between the three species?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0028_007_28007632_qa_4/instruction.md b/tasks/0028_007_28007632_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..46d5eea9c3f33418fe5fab01b03fa7709bdc2764 --- /dev/null +++ b/tasks/0028_007_28007632_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of samples for each species in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0028_007_28007632_qa_4/task.toml b/tasks/0028_007_28007632_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e1b342936708ca905144209b2650e7c03abe75b7 --- /dev/null +++ b/tasks/0028_007_28007632_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0028_007_28007632_qa_4" +description = "What is the percentage of samples for each species in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/007/28007632.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "33.33" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "33.33" +QUESTION = "What is the percentage of samples for each species 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/0028_150_28150461_qa_1/instruction.md b/tasks/0028_150_28150461_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5f6d99240602dce2253733bb224080effe860be4 --- /dev/null +++ b/tasks/0028_150_28150461_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): +- fruit_data_with_colors.txt + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median fruit label in the dataset based on the statistical description? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0028_150_28150461_qa_1/task.toml b/tasks/0028_150_28150461_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0fbbd99c7ebbf71d6fba8eb3ff3dd6cf9265fcaa --- /dev/null +++ b/tasks/0028_150_28150461_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0028_150_28150461_qa_1" +description = "What is the median fruit label in the dataset based on the statistical description?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/150/28150461.ipynb_qa_1" +kaggle_dataset_name = "mjamilmoughal/fruits-with-colors-dataset" +gold_answer = "3.0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mjamilmoughal__fruits-with-colors-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mjamilmoughal/fruits-with-colors-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3.0" +QUESTION = "What is the median fruit label in the dataset based on the statistical description?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0028_198_28198239_qa_1/instruction.md b/tasks/0028_198_28198239_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9d3d1496a9c218b91f0920ae638869d75968d710 --- /dev/null +++ b/tasks/0028_198_28198239_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the number of samples in the training set after an 85-15 train-test split of the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0028_198_28198239_qa_1/task.toml b/tasks/0028_198_28198239_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..acdf8e0149e026ab8f3cb7ab3b6c6c5996ada501 --- /dev/null +++ b/tasks/0028_198_28198239_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0028_198_28198239_qa_1" +description = "What is the number of samples in the training set after an 85-15 train-test split of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0028/198/28198239.ipynb_qa_1" +kaggle_dataset_name = "geomack/spotifyclassification" +gold_answer = "1714" +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 = "geomack__spotifyclassification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "geomack/spotifyclassification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1714" +QUESTION = "What is the number of samples in the training set after an 85-15 train-test split of the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0029_448_29448999_qa_3/instruction.md b/tasks/0029_448_29448999_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3544dece42622512d8c3b8f5e38d518d813036a0 --- /dev/null +++ b/tasks/0029_448_29448999_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- housing.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many validation samples were allocated to each fold during the k-fold cross-validation process? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0029_448_29448999_qa_3/task.toml b/tasks/0029_448_29448999_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ef210fe7c2e97ba7ca1d5ff20e72f184e2ebd755 --- /dev/null +++ b/tasks/0029_448_29448999_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0029_448_29448999_qa_3" +description = "How many validation samples were allocated to each fold during the k-fold cross-validation process?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0029/448/29448999.ipynb_qa_3" +kaggle_dataset_name = "vikrishnan/boston-house-prices" +gold_answer = "101" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "vikrishnan__boston-house-prices" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "vikrishnan/boston-house-prices" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "101" +QUESTION = "How many validation samples were allocated to each fold during the k-fold cross-validation process?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0030_284_30284375_qa_1/instruction.md b/tasks/0030_284_30284375_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..61cac27b9868daf13158d553e502b28555cc3a66 --- /dev/null +++ b/tasks/0030_284_30284375_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- AER_credit_card_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the average cross-validation accuracy before removing potential leaky features in the credit card 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/0030_284_30284375_qa_1/task.toml b/tasks/0030_284_30284375_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..32a3dac332db78d9cd9cbeeae30b25966110f42a --- /dev/null +++ b/tasks/0030_284_30284375_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0030_284_30284375_qa_1" +description = "What was the average cross-validation accuracy before removing potential leaky features in the credit card dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0030/284/30284375.ipynb_qa_1" +kaggle_dataset_name = "dansbecker/aer-credit-card-data" +gold_answer = "0.9802915082382764" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "dansbecker__aer-credit-card-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dansbecker/aer-credit-card-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.9802915082382764" +QUESTION = "What was the average cross-validation accuracy before removing potential leaky features in the credit card dataset analysis?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0031_374_31374028_qa_4/instruction.md b/tasks/0031_374_31374028_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2db0105acf5653b11bb03f0c3ff7577cfac63f58 --- /dev/null +++ b/tasks/0031_374_31374028_qa_4/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which pair of features shows the strongest negative correlation in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact feature names. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0031_374_31374028_qa_4/task.toml b/tasks/0031_374_31374028_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..38644c32e4f5267cd7185d43e81ea9b2e5f7c7da --- /dev/null +++ b/tasks/0031_374_31374028_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0031_374_31374028_qa_4" +description = "Which pair of features shows the strongest negative correlation in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/374/31374028.ipynb_qa_4" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "pH, fixed acidity" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "pH, fixed acidity" +QUESTION = "Which pair of features shows the strongest negative correlation in the dataset?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0031_600_31600148_qa_2/instruction.md b/tasks/0031_600_31600148_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8a968aef668b69a39e9e6504ac55cb190e765783 --- /dev/null +++ b/tasks/0031_600_31600148_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest recorded "energy" value in the dataset, and which song has this value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, value first, keep decimals). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0031_600_31600148_qa_2/task.toml b/tasks/0031_600_31600148_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..51953de0760c92be8ecc08018bc926a9f965a688 --- /dev/null +++ b/tasks/0031_600_31600148_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0031_600_31600148_qa_2" +description = "What is the highest recorded \"energy\" value in the dataset, and which song has this value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/600/31600148.ipynb_qa_2" +kaggle_dataset_name = "geomack/spotifyclassification" +gold_answer = "0.998, No Absolution" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "geomack__spotifyclassification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "geomack/spotifyclassification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.998, No Absolution" +QUESTION = "What is the highest recorded \"energy\" value in the dataset, and which song has this value?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0031_852_31852116_qa_2/instruction.md b/tasks/0031_852_31852116_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c0001d0f9f2c8f8cdbc77757bc0f9deb9c4d37b3 --- /dev/null +++ b/tasks/0031_852_31852116_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most important feature in predicting employee attrition according to SHAP 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/0031_852_31852116_qa_2/task.toml b/tasks/0031_852_31852116_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5ae4d47ea6274daf98e203875d8892218cb795a2 --- /dev/null +++ b/tasks/0031_852_31852116_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0031_852_31852116_qa_2" +description = "What is the most important feature in predicting employee attrition according to SHAP feature importance analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/852/31852116.ipynb_qa_2" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "OverTime" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "OverTime" +QUESTION = "What is the most important feature in predicting employee attrition according to SHAP 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/0031_872_31872499_qa_4/instruction.md b/tasks/0031_872_31872499_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..df0e671848912f6399d40006562736d5a9d21423 --- /dev/null +++ b/tasks/0031_872_31872499_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): +- diabetic_data.csv +- description.pdf + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After applying upsampling, what is the ratio of non-readmitted to readmitted patients in the resampled dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0031_872_31872499_qa_4/task.toml b/tasks/0031_872_31872499_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bf967e8cfea4770de302fe22ab493796c635f39c --- /dev/null +++ b/tasks/0031_872_31872499_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0031_872_31872499_qa_4" +description = "After applying upsampling, what is the ratio of non-readmitted to readmitted patients in the resampled dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/872/31872499.ipynb_qa_4" +kaggle_dataset_name = "brandao/diabetes" +gold_answer = "1:1" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "brandao__diabetes" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brandao/diabetes" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1:1" +QUESTION = "After applying upsampling, what is the ratio of non-readmitted to readmitted patients in the resampled 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/0031_927_31927038_qa_4/instruction.md b/tasks/0031_927_31927038_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f93cafe435522faea93d187973f0b3930d863380 --- /dev/null +++ b/tasks/0031_927_31927038_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: +What is the median age of patients in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0031_927_31927038_qa_4/task.toml b/tasks/0031_927_31927038_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..70f77966e1183c41ba7c9a5791f3cfb07bef3c4a --- /dev/null +++ b/tasks/0031_927_31927038_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0031_927_31927038_qa_4" +description = "What is the median age of patients in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/927/31927038.ipynb_qa_4" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "52" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "52" +QUESTION = "What is the median age of patients 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/0031_927_31927038_qa_5/instruction.md b/tasks/0031_927_31927038_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1b2b9c3fa0d295599fa316677dfc5e1e0fbf050f --- /dev/null +++ b/tasks/0031_927_31927038_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- haberman.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median number of axillary lymph nodes detected among the patients? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0031_927_31927038_qa_5/task.toml b/tasks/0031_927_31927038_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a331d7c7c4e58c2c0a0b03645ab98f90eeb6db8b --- /dev/null +++ b/tasks/0031_927_31927038_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0031_927_31927038_qa_5" +description = "What is the median number of axillary lymph nodes detected among the patients?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0031/927/31927038.ipynb_qa_5" +kaggle_dataset_name = "gilsousa/habermans-survival-data-set" +gold_answer = "1" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gilsousa__habermans-survival-data-set" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gilsousa/habermans-survival-data-set" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "What is the median number of axillary lymph nodes detected among the patients?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_069_32069437_qa_1/instruction.md b/tasks/0032_069_32069437_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6cf105f6babfb0d36b5d1a95e2937a96e96b9a06 --- /dev/null +++ b/tasks/0032_069_32069437_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- menu.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which food category has the highest average calorie count, and what is that average value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated pair with the category label first, then the average value as a plain number (e.g., 552.96), no extra text. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_069_32069437_qa_1/task.toml b/tasks/0032_069_32069437_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fc1079382c8afaebddeb447ab55f99f2e162325f --- /dev/null +++ b/tasks/0032_069_32069437_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_069_32069437_qa_1" +description = "Which food category has the highest average calorie count, and what is that average value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/069/32069437.ipynb_qa_1" +kaggle_dataset_name = "mcdonalds/nutrition-facts" +gold_answer = "Chicken & Fish, 552.96" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mcdonalds__nutrition-facts" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mcdonalds/nutrition-facts" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Chicken & Fish, 552.96" +QUESTION = "Which food category has the highest average calorie count, and what is that average value?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_178_32178295_qa_2/instruction.md b/tasks/0032_178_32178295_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9bf984d43a46bd5ba1d8ca1c829b09a9805bb56f --- /dev/null +++ b/tasks/0032_178_32178295_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diamonds.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum price of a diamond in the dataset before removing rows with zero dimensions? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_178_32178295_qa_2/task.toml b/tasks/0032_178_32178295_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0637addf28a08aec6e303e84958f1af3cd0d44f0 --- /dev/null +++ b/tasks/0032_178_32178295_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_178_32178295_qa_2" +description = "What is the maximum price of a diamond in the dataset before removing rows with zero dimensions?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/178/32178295.ipynb_qa_2" +kaggle_dataset_name = "shivam2503/diamonds" +gold_answer = "18823" +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 = "shivam2503__diamonds" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shivam2503/diamonds" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "18823" +QUESTION = "What is the maximum price of a diamond in the dataset before removing rows with zero dimensions?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_350_32350811_qa_5/instruction.md b/tasks/0032_350_32350811_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6a44c95388c4417da60d9107db34ecba0e0b7b0b --- /dev/null +++ b/tasks/0032_350_32350811_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 percentage of mobile phones in the dataset support 3G connectivity? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_350_32350811_qa_5/task.toml b/tasks/0032_350_32350811_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..01a6ab405eecac19469a8e46834bef67ca352527 --- /dev/null +++ b/tasks/0032_350_32350811_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_350_32350811_qa_5" +description = "What percentage of mobile phones in the dataset support 3G connectivity?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/350/32350811.ipynb_qa_5" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "76.15" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "76.15" +QUESTION = "What percentage of mobile phones in the dataset support 3G connectivity?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_431_32431999_qa_2/instruction.md b/tasks/0032_431_32431999_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..65d6cd14c89f4808a1f46e3e4c3bc994b29839d2 --- /dev/null +++ b/tasks/0032_431_32431999_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- norway_new_car_sales_by_month.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What was the highest monthly car sales quantity recorded in the dataset, and in which year and month did it occur? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0032_431_32431999_qa_2/task.toml b/tasks/0032_431_32431999_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cacb7aab278f5779c6588a688cfea758c93b3fd4 --- /dev/null +++ b/tasks/0032_431_32431999_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0032_431_32431999_qa_2" +description = "What was the highest monthly car sales quantity recorded in the dataset, and in which year and month did it occur?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/431/32431999.ipynb_qa_2" +kaggle_dataset_name = "dmi3kno/newcarsalesnorway" +gold_answer = "June 2015" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 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 = "dmi3kno__newcarsalesnorway" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dmi3kno/newcarsalesnorway" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "June 2015" +QUESTION = "What was the highest monthly car sales quantity recorded in the dataset, and in which year and month did it occur?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0032_431_32431999_qa_5/instruction.md b/tasks/0032_431_32431999_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3803f04f38764c558c1a11b7650a3380c7fa74b1 --- /dev/null +++ b/tasks/0032_431_32431999_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): +- norway_new_car_sales_by_month.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the autocorrelation of the car sales data significant in the early periods of the time series? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0032_431_32431999_qa_5/task.toml b/tasks/0032_431_32431999_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4bc9e2e8820f38d516db4f7fee462fa81766a45b --- /dev/null +++ b/tasks/0032_431_32431999_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0032_431_32431999_qa_5" +description = "Is the autocorrelation of the car sales data significant in the early periods of the time series?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0032/431/32431999.ipynb_qa_5" +kaggle_dataset_name = "dmi3kno/newcarsalesnorway" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "dmi3kno__newcarsalesnorway" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "dmi3kno/newcarsalesnorway" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the autocorrelation of the car sales data significant in the early periods of the time series?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0033_509_33509634_qa_1/instruction.md b/tasks/0033_509_33509634_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f212216f3ac2936d172d0de44e0d9079413adb9d --- /dev/null +++ b/tasks/0033_509_33509634_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- kc_house_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which two variables, when used together, achieve a perfect R² (1.0) in predicting the sqft_living feature? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact column names. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0033_509_33509634_qa_1/task.toml b/tasks/0033_509_33509634_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ad706f270ec58a1023679f55e8fa1c96618d2b12 --- /dev/null +++ b/tasks/0033_509_33509634_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0033_509_33509634_qa_1" +description = "Which two variables, when used together, achieve a perfect R² (1.0) in predicting the sqft_living feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/509/33509634.ipynb_qa_1" +kaggle_dataset_name = "harlfoxem/housesalesprediction" +gold_answer = "sqft_above, sqft_basement" +reward_mode_initial = "list" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "harlfoxem__housesalesprediction" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "harlfoxem/housesalesprediction" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "sqft_above, sqft_basement" +QUESTION = "Which two variables, when used together, achieve a perfect R² (1.0) in predicting the sqft_living feature?" +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/0033_652_33652373_qa_2/instruction.md b/tasks/0033_652_33652373_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bcc98d86999146f6a10479be89c758525eebc55a --- /dev/null +++ b/tasks/0033_652_33652373_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which BMI category has the highest average medical charges according to the distribution analysis in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0033_652_33652373_qa_2/task.toml b/tasks/0033_652_33652373_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1d448362a2f23c2bcec5d48dc8b372a653b9871c --- /dev/null +++ b/tasks/0033_652_33652373_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0033_652_33652373_qa_2" +description = "Which BMI category has the highest average medical charges according to the distribution analysis in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/652/33652373.ipynb_qa_2" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "Obese" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Obese" +QUESTION = "Which BMI category has the highest average medical charges according to the distribution analysis in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0033_652_33652373_qa_3/instruction.md b/tasks/0033_652_33652373_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..67e572898b1a51a9ca3f98966594869321c1e515 --- /dev/null +++ b/tasks/0033_652_33652373_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many individuals in the dataset have exactly 5 children? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0033_652_33652373_qa_3/task.toml b/tasks/0033_652_33652373_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..78a1b330a7e5d38723ed41157649a26f0072bb64 --- /dev/null +++ b/tasks/0033_652_33652373_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0033_652_33652373_qa_3" +description = "How many individuals in the dataset have exactly 5 children?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/652/33652373.ipynb_qa_3" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "18" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "18" +QUESTION = "How many individuals in the dataset have exactly 5 children?" +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_886_34886359_qa_3/instruction.md b/tasks/0034_886_34886359_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e2bfc859caecfa465aa147a02fd589a5ee51e7fd --- /dev/null +++ b/tasks/0034_886_34886359_qa_3/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the R-squared value of the linear regression model when evaluated on the test dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0034_886_34886359_qa_3/task.toml b/tasks/0034_886_34886359_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..63aadd30e82540dc1d64e1348c371ccafcb93cdb --- /dev/null +++ b/tasks/0034_886_34886359_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0034_886_34886359_qa_3" +description = "What is the R-squared value of the linear regression model when evaluated on the test dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/886/34886359.ipynb_qa_3" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "0.9888014444327563" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.9888014444327563" +QUESTION = "What is the R-squared value of the linear regression model when evaluated on the test dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_886_34886359_qa_5/instruction.md b/tasks/0034_886_34886359_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bec51d0f94afa2117f9e7f0e2fb2110bb825daf8 --- /dev/null +++ b/tasks/0034_886_34886359_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 mean squared error (MSE) of the linear regression model on the training data? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0034_886_34886359_qa_5/task.toml b/tasks/0034_886_34886359_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3c35dbfb552d11b8d81825c98e2cbe91e4f40ef6 --- /dev/null +++ b/tasks/0034_886_34886359_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0034_886_34886359_qa_5" +description = "What is the mean squared error (MSE) of the linear regression model on the training data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/886/34886359.ipynb_qa_5" +kaggle_dataset_name = "andonians/random-linear-regression" +gold_answer = "7.867752733487686" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "andonians__random-linear-regression" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "andonians/random-linear-regression" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7.867752733487686" +QUESTION = "What is the mean squared error (MSE) of the linear regression model on the training data?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_945_34945606_qa_2/instruction.md b/tasks/0034_945_34945606_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..72183b417d611e1b0b4f362f0f215314b59d8675 --- /dev/null +++ b/tasks/0034_945_34945606_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which education field has the highest attrition percentage among employees? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_945_34945606_qa_2/task.toml b/tasks/0034_945_34945606_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5d3c145682f414d6f859ba5308f0cfa4802d3457 --- /dev/null +++ b/tasks/0034_945_34945606_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0034_945_34945606_qa_2" +description = "Which education field has the highest attrition percentage among employees?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/945/34945606.ipynb_qa_2" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "Human Resources" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Human Resources" +QUESTION = "Which education field has the highest attrition percentage among employees?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0034_945_34945606_qa_5/instruction.md b/tasks/0034_945_34945606_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..af5715017057433fb943a5ce2bee74436a593e13 --- /dev/null +++ b/tasks/0034_945_34945606_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-HR-Employee-Attrition.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What job satisfaction level is most strongly correlated with employee attrition? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_945_34945606_qa_5/task.toml b/tasks/0034_945_34945606_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..cc67fffbd9b474c7aa08d10d85034073906abdd3 --- /dev/null +++ b/tasks/0034_945_34945606_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0034_945_34945606_qa_5" +description = "What job satisfaction level is most strongly correlated with employee attrition?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0034/945/34945606.ipynb_qa_5" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "1" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "pavansubhasht__ibm-hr-analytics-attrition-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "pavansubhasht/ibm-hr-analytics-attrition-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "What job satisfaction level is most strongly correlated with employee attrition?" +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_070_35070602_qa_2/instruction.md b/tasks/0035_070_35070602_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d957d8ec1486286095e0390dd1154c06b8e76834 --- /dev/null +++ b/tasks/0035_070_35070602_qa_2/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Submission.csv +- Test.csv +- Train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After preprocessing, how many missing values remain in both 'Item_Weight' and 'Outlet_Size'? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_070_35070602_qa_2/task.toml b/tasks/0035_070_35070602_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fd60c6b384c53d9301436ebef4ec2c30d9b2e2ec --- /dev/null +++ b/tasks/0035_070_35070602_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0035_070_35070602_qa_2" +description = "After preprocessing, how many missing values remain in both 'Item_Weight' and 'Outlet_Size'?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/070/35070602.ipynb_qa_2" +kaggle_dataset_name = "devashish0507/big-mart-sales-prediction" +gold_answer = "0" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "0" +QUESTION = "After preprocessing, how many missing values remain in both 'Item_Weight' and 'Outlet_Size'?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_074_35074138_qa_2/instruction.md b/tasks/0035_074_35074138_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a7451a7d6efb1f26da2169c3627189b1739f4dc0 --- /dev/null +++ b/tasks/0035_074_35074138_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- HR_comma_sep.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which department had the highest number of employees who left the company? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_074_35074138_qa_2/task.toml b/tasks/0035_074_35074138_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a58b9b8d9f6e72587cb2134860d105887fc101f4 --- /dev/null +++ b/tasks/0035_074_35074138_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_074_35074138_qa_2" +description = "Which department had the highest number of employees who left the company?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/074/35074138.ipynb_qa_2" +kaggle_dataset_name = "giripujar/hr-analytics" +gold_answer = "Sales" +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 = "giripujar__hr-analytics" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "giripujar/hr-analytics" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Sales" +QUESTION = "Which department had the highest number of employees who left the company?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_152_35152468_qa_2/instruction.md b/tasks/0035_152_35152468_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1cbf6d756301250cd5f7ae24ffcc076a6a95d394 --- /dev/null +++ b/tasks/0035_152_35152468_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique countries are represented in the customer data after cleaning missing values? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_152_35152468_qa_2/task.toml b/tasks/0035_152_35152468_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3715d9fdc2bda233ac6602e72cf3716969d6c942 --- /dev/null +++ b/tasks/0035_152_35152468_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_152_35152468_qa_2" +description = "How many unique countries are represented in the customer data after cleaning missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/152/35152468.ipynb_qa_2" +kaggle_dataset_name = "carrie1/ecommerce-data" +gold_answer = "37" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "carrie1__ecommerce-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "carrie1/ecommerce-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "37" +QUESTION = "How many unique countries are represented in the customer data after cleaning missing values?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_228_35228737_qa_5/instruction.md b/tasks/0035_228_35228737_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ea9caf79d347cb874d9e2e3d5b3f00afed6090ec --- /dev/null +++ b/tasks/0035_228_35228737_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature selection method (chi-squared test or Random Forest feature importance) yields higher mean cross-validation accuracy when using the top 7 features? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_228_35228737_qa_5/task.toml b/tasks/0035_228_35228737_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0ffb632660ad53057389f50180fe10e436791d18 --- /dev/null +++ b/tasks/0035_228_35228737_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0035_228_35228737_qa_5" +description = "Which feature selection method (chi-squared test or Random Forest feature importance) yields higher mean cross-validation accuracy when using the top 7 features?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/228/35228737.ipynb_qa_5" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "chi-squared test" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "chi-squared test" +QUESTION = "Which feature selection method (chi-squared test or Random Forest feature importance) yields higher mean cross-validation accuracy when using the top 7 features?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_236_35236430_qa_3/instruction.md b/tasks/0035_236_35236430_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cac28df451ee56d1ee38a6306cef1f8b331f3e45 --- /dev/null +++ b/tasks/0035_236_35236430_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the root mean squared error (RMSE) of the Linear Regression model built using sklearn on the test data? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_236_35236430_qa_3/task.toml b/tasks/0035_236_35236430_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..012c8d8abbd8a793c1a1b08b19727905bb82d47a --- /dev/null +++ b/tasks/0035_236_35236430_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_236_35236430_qa_3" +description = "What is the root mean squared error (RMSE) of the Linear Regression model built using sklearn on the test data?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/236/35236430.ipynb_qa_3" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "5786.98" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5786.98" +QUESTION = "What is the root mean squared error (RMSE) of the Linear Regression model built using sklearn on the test data?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_269_35269567_qa_2/instruction.md b/tasks/0035_269_35269567_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..77ade65a379d7f7b3ec17f2385ca69f3449cf59a --- /dev/null +++ b/tasks/0035_269_35269567_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which variable among OverallQual, GrLivArea, and GarageCars has the strongest statistically significant correlation with SalePrice? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_269_35269567_qa_2/task.toml b/tasks/0035_269_35269567_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b1728446dc6bbf1da968a340a582989c99f87cf7 --- /dev/null +++ b/tasks/0035_269_35269567_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0035_269_35269567_qa_2" +description = "Which variable among OverallQual, GrLivArea, and GarageCars has the strongest statistically significant correlation with SalePrice?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/269/35269567.ipynb_qa_2" +kaggle_dataset_name = "lespin/house-prices-dataset" +gold_answer = "OverallQual" +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 = "lespin__house-prices-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "lespin/house-prices-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "OverallQual" +QUESTION = "Which variable among OverallQual, GrLivArea, and GarageCars has the strongest statistically significant correlation with SalePrice?" +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_337_35337905_qa_1/instruction.md b/tasks/0035_337_35337905_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5c3400b9754ffdc171c413d8a2d1f3ced3574adf --- /dev/null +++ b/tasks/0035_337_35337905_qa_1/instruction.md @@ -0,0 +1,19 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- MedianHouseholdIncome2015.csv +- PercentagePeopleBelowPovertyLevel.csv +- PercentOver25CompletedHighSchool.csv +- ShareRaceByCity.csv +- PoliceKillingsUS.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between the poverty rate and the high school graduation rate across states in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_337_35337905_qa_1/task.toml b/tasks/0035_337_35337905_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8532bf7429c4bfd242296f5e3572eb22398dafac --- /dev/null +++ b/tasks/0035_337_35337905_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_337_35337905_qa_1" +description = "What is the correlation coefficient between the poverty rate and the high school graduation rate across states in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/337/35337905.ipynb_qa_1" +kaggle_dataset_name = "kwullum/fatal-police-shootings-in-the-us" +gold_answer = "-0.861672" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kwullum__fatal-police-shootings-in-the-us" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kwullum/fatal-police-shootings-in-the-us" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "-0.861672" +QUESTION = "What is the correlation coefficient between the poverty rate and the high school graduation rate across states 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/0035_638_35638998_qa_4/instruction.md b/tasks/0035_638_35638998_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..fa1bb8aacb8bf1a4d38012580592b93263d92761 --- /dev/null +++ b/tasks/0035_638_35638998_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): +- column_2C_weka.csv +- column_3C_weka.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature was identified as having the highest importance by both Decision Tree and Random Forest feature importance analyses? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_638_35638998_qa_4/task.toml b/tasks/0035_638_35638998_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9aa5c02ac349cda892f8619a4a473b92546d910b --- /dev/null +++ b/tasks/0035_638_35638998_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_638_35638998_qa_4" +description = "Which feature was identified as having the highest importance by both Decision Tree and Random Forest feature importance analyses?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/638/35638998.ipynb_qa_4" +kaggle_dataset_name = "uciml/biomechanical-features-of-orthopedic-patients" +gold_answer = "degree_spondylolisthesis" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__biomechanical-features-of-orthopedic-patients" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/biomechanical-features-of-orthopedic-patients" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "degree_spondylolisthesis" +QUESTION = "Which feature was identified as having the highest importance by both Decision Tree and Random Forest feature importance analyses?" +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_645_35645519_qa_3/instruction.md b/tasks/0035_645_35645519_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..2fef5a1ab934be17ecbc7ad66ce1bac842e578bb --- /dev/null +++ b/tasks/0035_645_35645519_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): +- sign_mnist_train.csv +- sign_mnist_test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the mean pixel intensity value of the first pixel (pixel1) across all images in the training dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_645_35645519_qa_3/task.toml b/tasks/0035_645_35645519_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a69f83be7f8c6198bdd7309959a928e17be8ee0a --- /dev/null +++ b/tasks/0035_645_35645519_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0035_645_35645519_qa_3" +description = "What is the mean pixel intensity value of the first pixel (pixel1) across all images in the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/645/35645519.ipynb_qa_3" +kaggle_dataset_name = "datamunge/sign-language-mnist" +gold_answer = "145.419377" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "datamunge__sign-language-mnist" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datamunge/sign-language-mnist" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "145.419377" +QUESTION = "What is the mean pixel intensity value of the first pixel (pixel1) across all images in the training dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0035_645_35645519_qa_4/instruction.md b/tasks/0035_645_35645519_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f5ed3d33a15c8eb1468e18aea9e64bbaab7759a1 --- /dev/null +++ b/tasks/0035_645_35645519_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): +- sign_mnist_train.csv +- sign_mnist_test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the standard deviation of pixel intensity values for the last pixel (pixel784) in the training dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0035_645_35645519_qa_4/task.toml b/tasks/0035_645_35645519_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0ada80e1276bf36bd2b11cf94631285cecb844e2 --- /dev/null +++ b/tasks/0035_645_35645519_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0035_645_35645519_qa_4" +description = "What is the standard deviation of pixel intensity values for the last pixel (pixel784) in the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0035/645/35645519.ipynb_qa_4" +kaggle_dataset_name = "datamunge/sign-language-mnist" +gold_answer = "64.396846" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "datamunge__sign-language-mnist" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "datamunge/sign-language-mnist" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "64.396846" +QUESTION = "What is the standard deviation of pixel intensity values for the last pixel (pixel784) in the training dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0036_275_36275138_qa_4/instruction.md b/tasks/0036_275_36275138_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..197a1d9a970bb51f0fe1cfc37020b1c722b500f2 --- /dev/null +++ b/tasks/0036_275_36275138_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which habitat type has the lowest proportion of poisonous mushrooms according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0036_275_36275138_qa_4/task.toml b/tasks/0036_275_36275138_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f6adf80818af116e35b25daf6037f3f1ddebc4d9 --- /dev/null +++ b/tasks/0036_275_36275138_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0036_275_36275138_qa_4" +description = "Which habitat type has the lowest proportion of poisonous mushrooms according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/275/36275138.ipynb_qa_4" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "Waste" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Waste" +QUESTION = "Which habitat type has the lowest proportion of poisonous mushrooms 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/0036_629_36629065_qa_2/instruction.md b/tasks/0036_629_36629065_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9fcc49fa5d5d3de00c41d93b0bbe80500b2d8d47 --- /dev/null +++ b/tasks/0036_629_36629065_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many missing values were present in the 'Year' column of the dataset before data cleaning? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0036_629_36629065_qa_2/task.toml b/tasks/0036_629_36629065_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..430c82470ac47e5a25ff42c24ebfc4169ecc139a --- /dev/null +++ b/tasks/0036_629_36629065_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0036_629_36629065_qa_2" +description = "How many missing values were present in the 'Year' column of the dataset before data cleaning?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/629/36629065.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "271" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "271" +QUESTION = "How many missing values were present in the 'Year' column of the dataset before data cleaning?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0036_800_36800377_qa_3/instruction.md b/tasks/0036_800_36800377_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3cd13dac34a18156c672dc9f08035c0a5c208cbc --- /dev/null +++ b/tasks/0036_800_36800377_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common embarkation point (Embarked) for passengers after replacing missing values with the most frequent port? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_800_36800377_qa_3/task.toml b/tasks/0036_800_36800377_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ea4d2114e4af41b11c02d408a71e94b7d168fd62 --- /dev/null +++ b/tasks/0036_800_36800377_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0036_800_36800377_qa_3" +description = "What is the most common embarkation point (Embarked) for passengers after replacing missing values with the most frequent port?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/800/36800377.ipynb_qa_3" +kaggle_dataset_name = "sweetyparmar1/titanic" +gold_answer = "S" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "sweetyparmar1__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sweetyparmar1/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "S" +QUESTION = "What is the most common embarkation point (Embarked) for passengers after replacing missing values with the most frequent port?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0036_800_36800377_qa_4/instruction.md b/tasks/0036_800_36800377_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e6c6caa6c80be508a327329bb38c1658c2dc5523 --- /dev/null +++ b/tasks/0036_800_36800377_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which passenger class (Pclass) had the highest number of passengers 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/0036_800_36800377_qa_4/task.toml b/tasks/0036_800_36800377_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a71332f16230c11e4f33084c5f85681913051e8d --- /dev/null +++ b/tasks/0036_800_36800377_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0036_800_36800377_qa_4" +description = "Which passenger class (Pclass) had the highest number of passengers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/800/36800377.ipynb_qa_4" +kaggle_dataset_name = "sweetyparmar1/titanic" +gold_answer = "3" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "sweetyparmar1__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sweetyparmar1/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "Which passenger class (Pclass) had the highest number of passengers in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0036_800_36800377_qa_5/instruction.md b/tasks/0036_800_36800377_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9d0107eaadce88b32ebf956901d98c0db08b911e --- /dev/null +++ b/tasks/0036_800_36800377_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Among the available cabin levels (C, B, D, etc.), which level had the highest number of passengers 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/0036_800_36800377_qa_5/task.toml b/tasks/0036_800_36800377_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bda193359adcba0444a2bc32301d8006114c1af9 --- /dev/null +++ b/tasks/0036_800_36800377_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0036_800_36800377_qa_5" +description = "Among the available cabin levels (C, B, D, etc.), which level had the highest number of passengers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/800/36800377.ipynb_qa_5" +kaggle_dataset_name = "sweetyparmar1/titanic" +gold_answer = "C" +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 = "sweetyparmar1__titanic" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sweetyparmar1/titanic" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "C" +QUESTION = "Among the available cabin levels (C, B, D, etc.), which level had the highest number of passengers in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0036_817_36817810_qa_4/instruction.md b/tasks/0036_817_36817810_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..68aa19115d6756d92bcaaa7ae4bbea9981984e28 --- /dev/null +++ b/tasks/0036_817_36817810_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): +- insurance.csv +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the difference between the maximum and minimum medical charges in the customized dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0036_817_36817810_qa_4/task.toml b/tasks/0036_817_36817810_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..879ec6f35b8ec6b696a400397b6f68f14cbfce56 --- /dev/null +++ b/tasks/0036_817_36817810_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0036_817_36817810_qa_4" +description = "What is the difference between the maximum and minimum medical charges in the customized dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0036/817/36817810.ipynb_qa_4" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "63275.039651" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "63275.039651" +QUESTION = "What is the difference between the maximum and minimum medical charges in the customized 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/0037_209_37209957_qa_5/instruction.md b/tasks/0037_209_37209957_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5fca040cb7ea7f301b504d835bb7bf2eb9d9875f --- /dev/null +++ b/tasks/0037_209_37209957_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common genre directed by Adam McKay in the training dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0037_209_37209957_qa_5/task.toml b/tasks/0037_209_37209957_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dfb0fc1a92e15ecaabf77d47db1d3858dc7ca2ac --- /dev/null +++ b/tasks/0037_209_37209957_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0037_209_37209957_qa_5" +description = "What is the most common genre directed by Adam McKay in the training dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/209/37209957.ipynb_qa_5" +kaggle_dataset_name = "PromptCloudHQ/imdb-data" +gold_answer = "Comedy" +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 = "PromptCloudHQ__imdb-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "PromptCloudHQ/imdb-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Comedy" +QUESTION = "What is the most common genre directed by Adam McKay in the training dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0037_513_37513711_qa_2/instruction.md b/tasks/0037_513_37513711_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..28d90277a1cf21723ef52757b1f95f9a63d2939f --- /dev/null +++ b/tasks/0037_513_37513711_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): +- GroceryStoreDataSet.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which individual product has the highest support value in the frequent itemsets? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_513_37513711_qa_2/task.toml b/tasks/0037_513_37513711_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8178c006d8a6af425087c101c1fd3d6dc0ee2d76 --- /dev/null +++ b/tasks/0037_513_37513711_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0037_513_37513711_qa_2" +description = "Which individual product has the highest support value in the frequent itemsets?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/513/37513711.ipynb_qa_2" +kaggle_dataset_name = "shazadudwadia/supermarket" +gold_answer = "BREAD" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shazadudwadia__supermarket" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shazadudwadia/supermarket" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "BREAD" +QUESTION = "Which individual product has the highest support value in the frequent itemsets?" +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_918_37918087_qa_4/instruction.md b/tasks/0037_918_37918087_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4301f9ca14dc87094b1bcecd1222e072ea83fe50 --- /dev/null +++ b/tasks/0037_918_37918087_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which price range class has the lowest precision according to the classification report? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0037_918_37918087_qa_4/task.toml b/tasks/0037_918_37918087_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..162d4d76d3aa4589199ab68fcb55ebf54916c89a --- /dev/null +++ b/tasks/0037_918_37918087_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0037_918_37918087_qa_4" +description = "Which price range class has the lowest precision according to the classification report?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0037/918/37918087.ipynb_qa_4" +kaggle_dataset_name = "iabhishekofficial/mobile-price-classification" +gold_answer = "2" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "iabhishekofficial__mobile-price-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "iabhishekofficial/mobile-price-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "Which price range class has the lowest precision according to the classification report?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0038_159_38159473_qa_2/instruction.md b/tasks/0038_159_38159473_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..18783655acd356793414d1157328ddc87b3b22a0 --- /dev/null +++ b/tasks/0038_159_38159473_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): +- party_in_nyc.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common location type for party-related incidents across all boroughs? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0038_159_38159473_qa_2/task.toml b/tasks/0038_159_38159473_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..265dc48418e81e1eda0161a243c969734b047b75 --- /dev/null +++ b/tasks/0038_159_38159473_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_159_38159473_qa_2" +description = "What is the most common location type for party-related incidents across all boroughs?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/159/38159473.ipynb_qa_2" +kaggle_dataset_name = "somesnm/partynyc" +gold_answer = "Residential Building/House" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "somesnm__partynyc" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "somesnm/partynyc" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Residential Building/House" +QUESTION = "What is the most common location type for party-related incidents across all boroughs?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0038_159_38159473_qa_4/instruction.md b/tasks/0038_159_38159473_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..aa342b33e4c662deaccf1c8719bbe0bab4b115b4 --- /dev/null +++ b/tasks/0038_159_38159473_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): +- party_in_nyc.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What day of the week had the highest number of party-related incidents? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0038_159_38159473_qa_4/task.toml b/tasks/0038_159_38159473_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..fa74c42981c6f768cced265fbb4d1c18e8180454 --- /dev/null +++ b/tasks/0038_159_38159473_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_159_38159473_qa_4" +description = "What day of the week had the highest number of party-related incidents?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/159/38159473.ipynb_qa_4" +kaggle_dataset_name = "somesnm/partynyc" +gold_answer = "Saturday" +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 = "somesnm__partynyc" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "somesnm/partynyc" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Saturday" +QUESTION = "What day of the week had the highest number of party-related incidents?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0038_412_38412209_qa_2/instruction.md b/tasks/0038_412_38412209_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cf4c04a7af586ab65cb14236ac7c99ad9b13cd7f --- /dev/null +++ b/tasks/0038_412_38412209_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 publisher holds the largest market share in global sales according to the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0038_412_38412209_qa_2/task.toml b/tasks/0038_412_38412209_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4ae5b3d8549ebdd240672618b1ab4621c3e8737d --- /dev/null +++ b/tasks/0038_412_38412209_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_412_38412209_qa_2" +description = "Which publisher holds the largest market share in global sales according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/412/38412209.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Nintendo" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Nintendo" +QUESTION = "Which publisher holds the largest market share in global sales according to the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0038_412_38412209_qa_5/instruction.md b/tasks/0038_412_38412209_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e33d63be3dedba8538ba1f7b5b7943247a751d40 --- /dev/null +++ b/tasks/0038_412_38412209_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which video game achieved the highest sales specifically in Japan 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/0038_412_38412209_qa_5/task.toml b/tasks/0038_412_38412209_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0c8edc144b1a086f87b509dcfa745b84917fc1dc --- /dev/null +++ b/tasks/0038_412_38412209_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0038_412_38412209_qa_5" +description = "Which video game achieved the highest sales specifically in Japan according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/412/38412209.ipynb_qa_5" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "Pokemon Red/Pokemon Blue" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Pokemon Red/Pokemon Blue" +QUESTION = "Which video game achieved the highest sales specifically in Japan 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/0038_673_38673777_qa_1/instruction.md b/tasks/0038_673_38673777_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..937e95a8cfbccfac9f53464cc5d90e26d5bc7747 --- /dev/null +++ b/tasks/0038_673_38673777_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the total global sales (in millions) of Action and Shooter games on Xbox and PS platforms that sold over 3 million copies in both North America and Europe? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0038_673_38673777_qa_1/task.toml b/tasks/0038_673_38673777_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..ec02fcca60d0c17b5fa945d8f3320c5c35671cb1 --- /dev/null +++ b/tasks/0038_673_38673777_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0038_673_38673777_qa_1" +description = "What is the total global sales (in millions) of Action and Shooter games on Xbox and PS platforms that sold over 3 million copies in both North America and Europe?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0038/673/38673777.ipynb_qa_1" +kaggle_dataset_name = "kedokedokedo/vgsales" +gold_answer = "231.98" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kedokedokedo__vgsales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kedokedokedo/vgsales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "231.98" +QUESTION = "What is the total global sales (in millions) of Action and Shooter games on Xbox and PS platforms that sold over 3 million copies in both North America and Europe?" +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_126_39126060_qa_2/instruction.md b/tasks/0039_126_39126060_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4da35ee982a6800a75de2aaecc39f33d47c85959 --- /dev/null +++ b/tasks/0039_126_39126060_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the standard deviation of sepal width in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_126_39126060_qa_2/task.toml b/tasks/0039_126_39126060_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..45b5dc0131d23f360ce24d02a6ecce40f9631716 --- /dev/null +++ b/tasks/0039_126_39126060_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_126_39126060_qa_2" +description = "What is the standard deviation of sepal width in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/126/39126060.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "0.433594" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.433594" +QUESTION = "What is the standard deviation of sepal width in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_159_39159070_qa_2/instruction.md b/tasks/0039_159_39159070_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3a7f42e2fd749deb60f5bf4e3ce6f773bcc089aa --- /dev/null +++ b/tasks/0039_159_39159070_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which gaming platform has the highest average Global_Sales according to the dataset analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_159_39159070_qa_2/task.toml b/tasks/0039_159_39159070_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..4659251cdc77441b9a7ea795eb04858044fafffe --- /dev/null +++ b/tasks/0039_159_39159070_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_159_39159070_qa_2" +description = "Which gaming platform has the highest average Global_Sales according to the dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/159/39159070.ipynb_qa_2" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "GB" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "GB" +QUESTION = "Which gaming platform has the highest average Global_Sales according to the dataset analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_289_39289264_qa_1/instruction.md b/tasks/0039_289_39289264_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..675b681115cd549bc55d822f503296227b12b934 --- /dev/null +++ b/tasks/0039_289_39289264_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): +- student-mat.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the correlation coefficient between the first period grade (G1) and the second period grade (G2) in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_289_39289264_qa_1/task.toml b/tasks/0039_289_39289264_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..50e7f1256180e7562b47821951d84d105ccaced4 --- /dev/null +++ b/tasks/0039_289_39289264_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_289_39289264_qa_1" +description = "What is the correlation coefficient between the first period grade (G1) and the second period grade (G2) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/289/39289264.ipynb_qa_1" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "0.852" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.852" +QUESTION = "What is the correlation coefficient between the first period grade (G1) and the second period grade (G2) in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_450_39450914_qa_3/instruction.md b/tasks/0039_450_39450914_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d10bb0469a0258cc9e9db6c90464ccc4d5f66739 --- /dev/null +++ b/tasks/0039_450_39450914_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most common platform among games with the lowest global sales (0.01 million)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_450_39450914_qa_3/task.toml b/tasks/0039_450_39450914_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0fc425ac83f9c89b0b314998d14bf347f5c7705f --- /dev/null +++ b/tasks/0039_450_39450914_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_450_39450914_qa_3" +description = "What is the most common platform among games with the lowest global sales (0.01 million)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/450/39450914.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "PC" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PC" +QUESTION = "What is the most common platform among games with the lowest global sales (0.01 million)?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_450_39450914_qa_4/instruction.md b/tasks/0039_450_39450914_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7b26c26b57e8c67beb117d88dcb365ad70fa1fb8 --- /dev/null +++ b/tasks/0039_450_39450914_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which platform has the highest number of games listed in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_450_39450914_qa_4/task.toml b/tasks/0039_450_39450914_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..f84bd87ae31294e7b9b3747dcdbbc565f992eeff --- /dev/null +++ b/tasks/0039_450_39450914_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_450_39450914_qa_4" +description = "Which platform has the highest number of games listed in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/450/39450914.ipynb_qa_4" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "DS" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "DS" +QUESTION = "Which platform has the highest number of games listed in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_667_39667959_qa_5/instruction.md b/tasks/0039_667_39667959_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..180320dc8739f0e876a4104b6fea81574709fc06 --- /dev/null +++ b/tasks/0039_667_39667959_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average sepal width for the Iris-setosa species in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_667_39667959_qa_5/task.toml b/tasks/0039_667_39667959_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..7120cbfe2096119adc26ec94787d5a3c02ee2bf0 --- /dev/null +++ b/tasks/0039_667_39667959_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_667_39667959_qa_5" +description = "What is the average sepal width for the Iris-setosa species in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/667/39667959.ipynb_qa_5" +kaggle_dataset_name = "uciml/iris" +gold_answer = "3.418" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3.418" +QUESTION = "What is the average sepal width for the Iris-setosa species in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.001" +RTOL = "0.005" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_714_39714962_qa_2/instruction.md b/tasks/0039_714_39714962_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c2d2726997d69df07e662d6d6b202ab0d6c9c2ab --- /dev/null +++ b/tasks/0039_714_39714962_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): +- Automobile_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Are the median prices of two-door and four-door cars statistically significantly different according to the dataset analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_714_39714962_qa_2/task.toml b/tasks/0039_714_39714962_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5a087d3886826f0b86112b530d72db1a136dc1bb --- /dev/null +++ b/tasks/0039_714_39714962_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_714_39714962_qa_2" +description = "Are the median prices of two-door and four-door cars statistically significantly different according to the dataset analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/714/39714962.ipynb_qa_2" +kaggle_dataset_name = "toramky/automobile-dataset" +gold_answer = "no" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "toramky__automobile-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "toramky/automobile-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "no" +QUESTION = "Are the median prices of two-door and four-door cars statistically significantly different according to the dataset analysis?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_715_39715876_qa_1/instruction.md b/tasks/0039_715_39715876_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..49afe0b4624f52b71fa03f74689c0c66347aaca0 --- /dev/null +++ b/tasks/0039_715_39715876_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which Iris species exhibits the highest number of features with positive skewness based on the mean-median analysis? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_715_39715876_qa_1/task.toml b/tasks/0039_715_39715876_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3c861c514a5292d1d5058eb8f34e6c25e7a33505 --- /dev/null +++ b/tasks/0039_715_39715876_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_715_39715876_qa_1" +description = "Which Iris species exhibits the highest number of features with positive skewness based on the mean-median analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/715/39715876.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "Iris-setosa" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Iris-setosa" +QUESTION = "Which Iris species exhibits the highest number of features with positive skewness based on the mean-median analysis?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_810_39810401_qa_2/instruction.md b/tasks/0039_810_39810401_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d067d6ba715719fb3aedf974593864f67613a19f --- /dev/null +++ b/tasks/0039_810_39810401_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): +- multipleChoiceResponses.csv +- schema.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequently selected machine learning tool among respondents planning to learn new tools/technologies in the future? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_810_39810401_qa_2/task.toml b/tasks/0039_810_39810401_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..80e6c69a834d08f363803b750d26dad213c7aed1 --- /dev/null +++ b/tasks/0039_810_39810401_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0039_810_39810401_qa_2" +description = "What is the most frequently selected machine learning tool among respondents planning to learn new tools/technologies in the future?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/810/39810401.ipynb_qa_2" +kaggle_dataset_name = "kaggle/kaggle-survey-2017" +gold_answer = "TensorFlow" +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 = "kaggle__kaggle-survey-2017" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kaggle/kaggle-survey-2017" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "TensorFlow" +QUESTION = "What is the most frequently selected machine learning tool among respondents planning to learn new tools/technologies in the future?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_818_39818487_qa_3/instruction.md b/tasks/0039_818_39818487_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..75eca63a1830816964fddb8824158066d22ca7b6 --- /dev/null +++ b/tasks/0039_818_39818487_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which transmission type is more common in the dataset after removing duplicates and missing values? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_818_39818487_qa_3/task.toml b/tasks/0039_818_39818487_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..762865f3c9694886d7efb2134eca1a2aa69afbc0 --- /dev/null +++ b/tasks/0039_818_39818487_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_818_39818487_qa_3" +description = "Which transmission type is more common in the dataset after removing duplicates and missing values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/818/39818487.ipynb_qa_3" +kaggle_dataset_name = "CooperUnion/cardataset" +gold_answer = "AUTOMATIC" +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 = "CooperUnion__cardataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "CooperUnion/cardataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "AUTOMATIC" +QUESTION = "Which transmission type is more common in the dataset after removing duplicates and missing values?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_850_39850014_qa_2/instruction.md b/tasks/0039_850_39850014_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a6866b6ecc5162d5aeefe9472b6d32cc53669c47 --- /dev/null +++ b/tasks/0039_850_39850014_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): +- papers.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many missing values are present in the 'event_type' column of the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0039_850_39850014_qa_2/task.toml b/tasks/0039_850_39850014_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2d33f6b991affa7edf3d3d3ecf0b5eb1a179984b --- /dev/null +++ b/tasks/0039_850_39850014_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_850_39850014_qa_2" +description = "How many missing values are present in the 'event_type' column of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/850/39850014.ipynb_qa_2" +kaggle_dataset_name = "benhamner/nips-papers" +gold_answer = "4819" +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 = "benhamner__nips-papers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "benhamner/nips-papers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4819" +QUESTION = "How many missing values are present in the 'event_type' column of the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_850_39850014_qa_3/instruction.md b/tasks/0039_850_39850014_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f92a60792ea8c5403d5fa0f5f5821aa30b60f8f4 --- /dev/null +++ b/tasks/0039_850_39850014_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): +- papers.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many papers in the dataset have fewer than 50 words in their text content? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_850_39850014_qa_3/task.toml b/tasks/0039_850_39850014_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6cb529191e89a6865105e16e60dff0ad10937987 --- /dev/null +++ b/tasks/0039_850_39850014_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0039_850_39850014_qa_3" +description = "How many papers in the dataset have fewer than 50 words in their text content?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/850/39850014.ipynb_qa_3" +kaggle_dataset_name = "benhamner/nips-papers" +gold_answer = "3" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "benhamner__nips-papers" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "benhamner/nips-papers" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many papers in the dataset have fewer than 50 words in their text content?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0039_968_39968264_qa_3/instruction.md b/tasks/0039_968_39968264_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..929b85d2207db2370cb33d96fe96df57be6a5b49 --- /dev/null +++ b/tasks/0039_968_39968264_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Does adjusting the weights parameter from 'uniform' to 'distance' result in a statistically significant improvement in test accuracy when all other parameters are set to their default 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/0039_968_39968264_qa_3/task.toml b/tasks/0039_968_39968264_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..998c020fd23819f03b279632aaa2f68f352814d3 --- /dev/null +++ b/tasks/0039_968_39968264_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0039_968_39968264_qa_3" +description = "Does adjusting the weights parameter from 'uniform' to 'distance' result in a statistically significant improvement in test accuracy when all other parameters are set to their default values?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0039/968/39968264.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "no" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "no" +QUESTION = "Does adjusting the weights parameter from 'uniform' to 'distance' result in a statistically significant improvement in test accuracy when all other parameters are set to their default values?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_340_40340401_qa_2/instruction.md b/tasks/0040_340_40340401_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..514e3d0c89d413f985926b806ebb46ed433ef050 --- /dev/null +++ b/tasks/0040_340_40340401_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the Pearson correlation coefficient between alcohol content and wine quality as observed in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_340_40340401_qa_2/task.toml b/tasks/0040_340_40340401_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..141815d97fe6f7a738d8319ad7426b2e6b4d6409 --- /dev/null +++ b/tasks/0040_340_40340401_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_340_40340401_qa_2" +description = "What is the Pearson correlation coefficient between alcohol content and wine quality as observed in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/340/40340401.ipynb_qa_2" +kaggle_dataset_name = "maitree/wine-quality-selection" +gold_answer = "0.47" +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 = "maitree__wine-quality-selection" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "maitree/wine-quality-selection" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0.47" +QUESTION = "What is the Pearson correlation coefficient between alcohol content and wine quality as observed in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_340_40340401_qa_3/instruction.md b/tasks/0040_340_40340401_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d60a4cff66fab58a98e2191cffd5ab41e889483b --- /dev/null +++ b/tasks/0040_340_40340401_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the correlation between total acidity and pH in the dataset 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/0040_340_40340401_qa_3/task.toml b/tasks/0040_340_40340401_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d4309292eea44643bc277939bd7e12ff06041287 --- /dev/null +++ b/tasks/0040_340_40340401_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_340_40340401_qa_3" +description = "Is the correlation between total acidity and pH in the dataset 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 = "0040/340/40340401.ipynb_qa_3" +kaggle_dataset_name = "maitree/wine-quality-selection" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "maitree__wine-quality-selection" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "maitree/wine-quality-selection" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the correlation between total acidity and pH in the dataset statistically significant at the 0.05 significance level?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_340_40340401_qa_4/instruction.md b/tasks/0040_340_40340401_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..73c66dc5dd6f638f962c9a109d26976fdbd2438b --- /dev/null +++ b/tasks/0040_340_40340401_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median alcohol content of the wines in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_340_40340401_qa_4/task.toml b/tasks/0040_340_40340401_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..1ef62579e5b72cf66222e0d0f68207ac868be26c --- /dev/null +++ b/tasks/0040_340_40340401_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0040_340_40340401_qa_4" +description = "What is the median alcohol content of the wines in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/340/40340401.ipynb_qa_4" +kaggle_dataset_name = "maitree/wine-quality-selection" +gold_answer = "10.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 = "maitree__wine-quality-selection" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "maitree/wine-quality-selection" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "10.2" +QUESTION = "What is the median alcohol content of the wines in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_528_40528853_qa_4/instruction.md b/tasks/0040_528_40528853_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..468f9b4ac677e6131b5fff936ec6be1dea410fb1 --- /dev/null +++ b/tasks/0040_528_40528853_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is the correlation between age and charges in the dataset statistically significant based on the model results? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_528_40528853_qa_4/task.toml b/tasks/0040_528_40528853_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2d439821436f4b8b1ed1ea6b65c8ff9705ff12fe --- /dev/null +++ b/tasks/0040_528_40528853_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0040_528_40528853_qa_4" +description = "Is the correlation between age and charges in the dataset statistically significant based on the model results?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/528/40528853.ipynb_qa_4" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is the correlation between age and charges in the dataset statistically significant based on the model results?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_620_40620313_qa_3/instruction.md b/tasks/0040_620_40620313_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..08f9c464570eb0a051f09706c33f2f0ea22c9942 --- /dev/null +++ b/tasks/0040_620_40620313_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many samples are allocated to the test set after splitting the data with a 20% test size? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_620_40620313_qa_3/task.toml b/tasks/0040_620_40620313_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..320a90e5b48505bad95e443aaacab36b689d642a --- /dev/null +++ b/tasks/0040_620_40620313_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_620_40620313_qa_3" +description = "How many samples are allocated to the test set after splitting the data with a 20% test size?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/620/40620313.ipynb_qa_3" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "114" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "114" +QUESTION = "How many samples are allocated to the test set after splitting the data with a 20% test size?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_620_40620313_qa_5/instruction.md b/tasks/0040_620_40620313_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e91096d708ca216ae97be7bef42060ef03d30889 --- /dev/null +++ b/tasks/0040_620_40620313_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many missing values are present in the 'Unnamed: 32' column of the original dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_620_40620313_qa_5/task.toml b/tasks/0040_620_40620313_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..009cc5d140330e293fd43cffe50f5fe538c519a8 --- /dev/null +++ b/tasks/0040_620_40620313_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_620_40620313_qa_5" +description = "How many missing values are present in the 'Unnamed: 32' column of the original dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/620/40620313.ipynb_qa_5" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "569" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "569" +QUESTION = "How many missing values are present in the 'Unnamed: 32' column of the original dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_736_40736477_qa_3/instruction.md b/tasks/0040_736_40736477_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c7dfa13e5dc81b5aaffa6831942f8a54333693c4 --- /dev/null +++ b/tasks/0040_736_40736477_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum year value in the dataset after correcting the anomalous entry? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_736_40736477_qa_3/task.toml b/tasks/0040_736_40736477_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..17c9172e8db0bb12884a1fba883c2d5073a42fd5 --- /dev/null +++ b/tasks/0040_736_40736477_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0040_736_40736477_qa_3" +description = "What is the maximum year value in the dataset after correcting the anomalous entry?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/736/40736477.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "2017" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2017" +QUESTION = "What is the maximum year value in the dataset after correcting the anomalous entry?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_826_40826860_qa_1/instruction.md b/tasks/0040_826_40826860_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..95426e121cf28bc8cdc28779be4a99e5fdbbadff --- /dev/null +++ b/tasks/0040_826_40826860_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which gaming platform has the highest number of games developed 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/0040_826_40826860_qa_1/task.toml b/tasks/0040_826_40826860_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..23a5a162b64a2a769e7a6c17ad9b6b4cfdc40acb --- /dev/null +++ b/tasks/0040_826_40826860_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0040_826_40826860_qa_1" +description = "Which gaming platform has the highest number of games developed based on the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/826/40826860.ipynb_qa_1" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "DS" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "DS" +QUESTION = "Which gaming platform has the highest number of games developed 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/0040_843_40843458_qa_4/instruction.md b/tasks/0040_843_40843458_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..97e4e8b4ee98c7ccc2e6602a9772778bf3b2ccd2 --- /dev/null +++ b/tasks/0040_843_40843458_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winemag-data-130k-v2.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which US province has the most wine reviews in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_843_40843458_qa_4/task.toml b/tasks/0040_843_40843458_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6ba55f5170ccfdb138355053692c409dbf65e6db --- /dev/null +++ b/tasks/0040_843_40843458_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0040_843_40843458_qa_4" +description = "Which US province has the most wine reviews in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/843/40843458.ipynb_qa_4" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "California" +reward_mode_initial = "exact_short" +package_tier = 3 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "California" +QUESTION = "Which US province has the most wine reviews in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0040_921_40921599_qa_1/instruction.md b/tasks/0040_921_40921599_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c96acf39c6dc38dcbf91e4192430f653b08bebde --- /dev/null +++ b/tasks/0040_921_40921599_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): +- HN_posts_year_to_Sep_26_2016.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which type of post (ask or show) has a higher average number of comments in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_921_40921599_qa_1/task.toml b/tasks/0040_921_40921599_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0903fcbfb22a2ba3ec94d3f2dc1c094e5674772f --- /dev/null +++ b/tasks/0040_921_40921599_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0040_921_40921599_qa_1" +description = "Which type of post (ask or show) has a higher average number of comments in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/921/40921599.ipynb_qa_1" +kaggle_dataset_name = "hacker-news/hacker-news-posts" +gold_answer = "ask" +reward_mode_initial = "exact_short" +package_tier = 3 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "hacker-news__hacker-news-posts" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "hacker-news/hacker-news-posts" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "ask" +QUESTION = "Which type of post (ask or show) has a higher average number of comments 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/0040_983_40983485_qa_1/instruction.md b/tasks/0040_983_40983485_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8c3b90268144dadf5f2a5e77150003c3baf273f9 --- /dev/null +++ b/tasks/0040_983_40983485_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- GroceryStoreDataSet.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the 4-itemset with the highest support count in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the exact item names, in the order given. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0040_983_40983485_qa_1/task.toml b/tasks/0040_983_40983485_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..79a00d79c425def48b576d35b961efee3f4642bb --- /dev/null +++ b/tasks/0040_983_40983485_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0040_983_40983485_qa_1" +description = "What is the 4-itemset with the highest support count in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/983/40983485.ipynb_qa_1" +kaggle_dataset_name = "shazadudwadia/supermarket" +gold_answer = "BISCUIT, COCK, COFFEE, CORNFLAKES" +reward_mode_initial = "list" +package_tier = 0 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shazadudwadia__supermarket" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shazadudwadia/supermarket" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "BISCUIT, COCK, COFFEE, CORNFLAKES" +QUESTION = "What is the 4-itemset with the highest support count in the dataset?" +REWARD_MODE = "list" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_156_41156002_qa_2/instruction.md b/tasks/0041_156_41156002_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..91cc5f8a66e82f00d0ab8aa27c28b52bd5e29b29 --- /dev/null +++ b/tasks/0041_156_41156002_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): +- 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 upper threshold value for the credit amount after applying the IQR method? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_156_41156002_qa_2/task.toml b/tasks/0041_156_41156002_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..99193bf8271fc8fcf0d68f707fe6ac924f199962 --- /dev/null +++ b/tasks/0041_156_41156002_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0041_156_41156002_qa_2" +description = "What is the upper threshold value for the credit amount after applying the IQR method?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/156/41156002.ipynb_qa_2" +kaggle_dataset_name = "kabure/german-credit-data-with-risk" +gold_answer = "7882.375" +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 = "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 = "7882.375" +QUESTION = "What is the upper threshold value for the credit amount after applying the IQR method?" +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/0041_156_41156002_qa_4/instruction.md b/tasks/0041_156_41156002_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b5add2e45742b349dd96c82eb1f2041613ef4b54 --- /dev/null +++ b/tasks/0041_156_41156002_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): +- german_credit_data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which age category has the highest count in the transformed 'katAge' variable? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_156_41156002_qa_4/task.toml b/tasks/0041_156_41156002_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..546bdd2073706ae6763a257cfcd0bb307817b767 --- /dev/null +++ b/tasks/0041_156_41156002_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0041_156_41156002_qa_4" +description = "Which age category has the highest count in the transformed 'katAge' variable?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/156/41156002.ipynb_qa_4" +kaggle_dataset_name = "kabure/german-credit-data-with-risk" +gold_answer = "Young" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "Young" +QUESTION = "Which age category has the highest count in the transformed 'katAge' variable?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_243_41243008_qa_3/instruction.md b/tasks/0041_243_41243008_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3a87847611ec612d4eaa826d9e45a008be534de2 --- /dev/null +++ b/tasks/0041_243_41243008_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- mushrooms.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the threshold value used in the root node of the decision tree model for splitting based on the 'gill-color' 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/0041_243_41243008_qa_3/task.toml b/tasks/0041_243_41243008_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8cdd9d63f7d90940c3bcf1a77848b10b969b9a20 --- /dev/null +++ b/tasks/0041_243_41243008_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_243_41243008_qa_3" +description = "What is the threshold value used in the root node of the decision tree model for splitting based on the 'gill-color' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/243/41243008.ipynb_qa_3" +kaggle_dataset_name = "uciml/mushroom-classification" +gold_answer = "3.5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__mushroom-classification" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/mushroom-classification" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3.5" +QUESTION = "What is the threshold value used in the root node of the decision tree model for splitting based on the 'gill-color' feature?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_421_41421779_qa_5/instruction.md b/tasks/0041_421_41421779_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e20b424d853a92ce289ab55e2b64e4b8a1d4b679 --- /dev/null +++ b/tasks/0041_421_41421779_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the precision score achieved by the RandomForest classifier on the test set for identifying spam messages? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_421_41421779_qa_5/task.toml b/tasks/0041_421_41421779_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..21b0681ae4f93c0e2842480ec895eafaf7c94d77 --- /dev/null +++ b/tasks/0041_421_41421779_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_421_41421779_qa_5" +description = "What is the precision score achieved by the RandomForest classifier on the test set for identifying spam messages?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/421/41421779.ipynb_qa_5" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "1.0" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__sms-spam-collection-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/sms-spam-collection-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.0" +QUESTION = "What is the precision score achieved by the RandomForest classifier on the test set for identifying spam messages?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_600_41600293_qa_3/instruction.md b/tasks/0041_600_41600293_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ed929dcb45c5a75d86cb721cfd5b1637bfe3596a --- /dev/null +++ b/tasks/0041_600_41600293_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many unique categories are present in the PaymentMethod column of the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_600_41600293_qa_3/task.toml b/tasks/0041_600_41600293_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3404b0d3fbbc3dc5267ec216e476bbd02e8fc9c9 --- /dev/null +++ b/tasks/0041_600_41600293_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0041_600_41600293_qa_3" +description = "How many unique categories are present in the PaymentMethod column of the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/600/41600293.ipynb_qa_3" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "4" +reward_mode_initial = "numeric" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "4" +QUESTION = "How many unique categories are present in the PaymentMethod column of the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_604_41604680_qa_3/instruction.md b/tasks/0041_604_41604680_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..ef06a8e115cbc8f7a90ec132c1d4ee49db2e0b13 --- /dev/null +++ b/tasks/0041_604_41604680_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct categories are present in the Outlet_Location_Type feature after data loading? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_604_41604680_qa_3/task.toml b/tasks/0041_604_41604680_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9a3704f6b7245a6baa9371801680f23c943dc9e3 --- /dev/null +++ b/tasks/0041_604_41604680_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_604_41604680_qa_3" +description = "How many distinct categories are present in the Outlet_Location_Type feature after data loading?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/604/41604680.ipynb_qa_3" +kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data" +gold_answer = "3" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "How many distinct categories are present in the Outlet_Location_Type feature after data loading?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_604_41604680_qa_5/instruction.md b/tasks/0041_604_41604680_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..f43e86de44824bf3b96425ce5ddf96748d8f34ea --- /dev/null +++ b/tasks/0041_604_41604680_qa_5/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Train.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What numerical values are assigned to the "Low Fat" and "Regular" categories when using LabelEncoder on the cleaned Item_Fat_Content column? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: = , = (comma-separated, category first, plain numbers). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_604_41604680_qa_5/task.toml b/tasks/0041_604_41604680_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0e6b6cce3af7b06dba318c2cbe99a13151240262 --- /dev/null +++ b/tasks/0041_604_41604680_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0041_604_41604680_qa_5" +description = "What numerical values are assigned to the \"Low Fat\" and \"Regular\" categories when using LabelEncoder on the cleaned Item_Fat_Content column?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/604/41604680.ipynb_qa_5" +kaggle_dataset_name = "brijbhushannanda1979/bigmart-sales-data" +gold_answer = "Low Fat = 0, Regular = 1" +reward_mode_initial = "flexible" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "brijbhushannanda1979__bigmart-sales-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "brijbhushannanda1979/bigmart-sales-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Low Fat = 0, Regular = 1" +QUESTION = "What numerical values are assigned to the \"Low Fat\" and \"Regular\" categories when using LabelEncoder on the cleaned Item_Fat_Content column?" +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/0041_998_41998385_qa_2/instruction.md b/tasks/0041_998_41998385_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..e76b9682b45544ca47a09e1b7aa35b4386122575 --- /dev/null +++ b/tasks/0041_998_41998385_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- WA_Fn-UseC_-Telco-Customer-Churn.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of customers in the dataset ultimately churned (left the service)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_998_41998385_qa_2/task.toml b/tasks/0041_998_41998385_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8e00d435228b248b051ff54a521e8e3dba52fdf0 --- /dev/null +++ b/tasks/0041_998_41998385_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_998_41998385_qa_2" +description = "What percentage of customers in the dataset ultimately churned (left the service)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/998/41998385.ipynb_qa_2" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "26.5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "26.5" +QUESTION = "What percentage of customers in the dataset ultimately churned (left the service)?" +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/0042_102_42102863_qa_1/instruction.md b/tasks/0042_102_42102863_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7e342733c21b8766b3b3fcdf93e8ffb32eb27772 --- /dev/null +++ b/tasks/0042_102_42102863_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature exhibits the strongest positive correlation with the diagnosis (encoded as 1 for Malignant) 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/0042_102_42102863_qa_1/task.toml b/tasks/0042_102_42102863_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e5ecad9416d4d2f48adadece2198c2dc4a34db70 --- /dev/null +++ b/tasks/0042_102_42102863_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0042_102_42102863_qa_1" +description = "Which feature exhibits the strongest positive correlation with the diagnosis (encoded as 1 for Malignant) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/102/42102863.ipynb_qa_1" +kaggle_dataset_name = "uciml/breast-cancer-wisconsin-data" +gold_answer = "concave points_worst" +reward_mode_initial = "exact_short" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__breast-cancer-wisconsin-data" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/breast-cancer-wisconsin-data" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "concave points_worst" +QUESTION = "Which feature exhibits the strongest positive correlation with the diagnosis (encoded as 1 for Malignant) in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0042_492_42492005_qa_3/instruction.md b/tasks/0042_492_42492005_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bed150ca12684fa0fd0bbc177ccba894ebe21c89 --- /dev/null +++ b/tasks/0042_492_42492005_qa_3/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many missing values remain in the 'Age' column after the imputation process? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0042_492_42492005_qa_3/task.toml b/tasks/0042_492_42492005_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3d039e47bfdd212f925b29a428a7fbc0068e48e4 --- /dev/null +++ b/tasks/0042_492_42492005_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0042_492_42492005_qa_3" +description = "How many missing values remain in the 'Age' column after the imputation process?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/492/42492005.ipynb_qa_3" +kaggle_dataset_name = "shuofxz/titanic-machine-learning-from-disaster" +gold_answer = "0" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "shuofxz__titanic-machine-learning-from-disaster" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "shuofxz/titanic-machine-learning-from-disaster" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "0" +QUESTION = "How many missing values remain in the 'Age' column after the imputation process?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0042_503_42503346_qa_4/instruction.md b/tasks/0042_503_42503346_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..77eeec2ae471fe3de22391cb5eeb6e6a46c9b859 --- /dev/null +++ b/tasks/0042_503_42503346_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 positive correlation with PetalWidthCm? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0042_503_42503346_qa_4/task.toml b/tasks/0042_503_42503346_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..460cbedbdc11ec90de92883841ced3df6b2d9137 --- /dev/null +++ b/tasks/0042_503_42503346_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0042_503_42503346_qa_4" +description = "Which feature has the highest positive correlation with PetalWidthCm?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/503/42503346.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalLengthCm" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PetalLengthCm" +QUESTION = "Which feature has the highest positive correlation with PetalWidthCm?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0042_993_42993650_qa_1/instruction.md b/tasks/0042_993_42993650_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..365bad0147b3a3a7d82b44a6b4b23120dd654273 --- /dev/null +++ b/tasks/0042_993_42993650_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Is there a statistically significant difference in the mean age between individuals earning more than $50K and those earning $50K or less? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0042_993_42993650_qa_1/task.toml b/tasks/0042_993_42993650_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..19f4d5edc90875704042f58e2443a6a9a0eb11ea --- /dev/null +++ b/tasks/0042_993_42993650_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0042_993_42993650_qa_1" +description = "Is there a statistically significant difference in the mean age between individuals earning more than $50K and those earning $50K or less?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/993/42993650.ipynb_qa_1" +kaggle_dataset_name = "uciml/adult-census-income" +gold_answer = "yes" +reward_mode_initial = "exact_bool" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__adult-census-income" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/adult-census-income" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Is there a statistically significant difference in the mean age between individuals earning more than $50K and those earning $50K or less?" +REWARD_MODE = "exact_bool" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0043_512_43512681_qa_5/instruction.md b/tasks/0043_512_43512681_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0898d1de841acd15c2e8c997fc69e25c4e64eb35 --- /dev/null +++ b/tasks/0043_512_43512681_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): +- kidney_disease.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +After converting the red_blood_cell_count to a numerical type, how many non-null entries does this feature have? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0043_512_43512681_qa_5/task.toml b/tasks/0043_512_43512681_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..9d7bd6f01b8a1010093b00e1223e562ad5d849a7 --- /dev/null +++ b/tasks/0043_512_43512681_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0043_512_43512681_qa_5" +description = "After converting the red_blood_cell_count to a numerical type, how many non-null entries does this feature have?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/512/43512681.ipynb_qa_5" +kaggle_dataset_name = "mansoordaku/ckdisease" +gold_answer = "269" +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 = "mansoordaku__ckdisease" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mansoordaku/ckdisease" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "269" +QUESTION = "After converting the red_blood_cell_count to a numerical type, how many non-null entries does this feature have?" +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/0043_936_43936231_qa_3/instruction.md b/tasks/0043_936_43936231_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..45b7c213f4de22de0f1f813c6b050dcaabbb551c --- /dev/null +++ b/tasks/0043_936_43936231_qa_3/instruction.md @@ -0,0 +1,16 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- train.csv +- test.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many passengers in the training dataset have missing embarkation information (Embarked)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0043_936_43936231_qa_3/task.toml b/tasks/0043_936_43936231_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..587176f47517bb6f482710f106ca9394d987e1ff --- /dev/null +++ b/tasks/0043_936_43936231_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0043_936_43936231_qa_3" +description = "How many passengers in the training dataset have missing embarkation information (Embarked)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/936/43936231.ipynb_qa_3" +kaggle_dataset_name = "sureshbhusare/titanic-dataset-from-kaggle" +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 = "sureshbhusare__titanic-dataset-from-kaggle" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "sureshbhusare/titanic-dataset-from-kaggle" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "2" +QUESTION = "How many passengers in the training dataset have missing embarkation information (Embarked)?" +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/0043_969_43969595_qa_5/instruction.md b/tasks/0043_969_43969595_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..eac6a0394d36e3288bd659442ce3f89ccb0d9fb7 --- /dev/null +++ b/tasks/0043_969_43969595_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- (see /home/user/input) + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of employees in the dataset who have attrited (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/0043_969_43969595_qa_5/task.toml b/tasks/0043_969_43969595_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..e91a27eb0cf776f239b485e86178f3ebc1800cdb --- /dev/null +++ b/tasks/0043_969_43969595_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0043_969_43969595_qa_5" +description = "What is the percentage of employees in the dataset who have attrited (Attrition = Yes)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/969/43969595.ipynb_qa_5" +kaggle_dataset_name = "pavansubhasht/ibm-hr-analytics-attrition-dataset" +gold_answer = "16.13" +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 = "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 = "16.13" +QUESTION = "What is the percentage of employees in the dataset who have attrited (Attrition = Yes)?" +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/0044_001_44001840_qa_1/instruction.md b/tasks/0044_001_44001840_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..cfdc0d248d878403e46dc00e9caf0d5e0e79476c --- /dev/null +++ b/tasks/0044_001_44001840_qa_1/instruction.md @@ -0,0 +1,17 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- column_2C_weka.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage distribution of abnormal and normal patients in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: %