diff --git a/tasks/0001_234_1234901_qa_3/instruction.md b/tasks/0001_234_1234901_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..570b403a32f87279b61560d7da15505c6e20f3b4 --- /dev/null +++ b/tasks/0001_234_1234901_qa_3/instruction.md @@ -0,0 +1,19 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- degrees-that-pay-back.csv +- salaries-by-college-type.csv +- salaries-by-region.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which undergraduate major has the highest mid-career median salary, and what is that value? + +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_234_1234901_qa_3/task.toml b/tasks/0001_234_1234901_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c21e4f65134da4770bd0336eb204d258561de604 --- /dev/null +++ b/tasks/0001_234_1234901_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0001_234_1234901_qa_3" +description = "Which undergraduate major has the highest mid-career median salary, and what is that value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/234/1234901.ipynb_qa_3" +kaggle_dataset_name = "wsj/college-salaries" +gold_answer = "Chemical Engineering, 107000" +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 = "wsj__college-salaries" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "wsj/college-salaries" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Chemical Engineering, 107000" +QUESTION = "Which undergraduate major has the highest mid-career median salary, and what is that value?" +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_435_1435960_qa_4/instruction.md b/tasks/0001_435_1435960_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..abd77a1359f7f99f506eec38bd36d61f8fe9be87 --- /dev/null +++ b/tasks/0001_435_1435960_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- adult.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the average hours per week for individuals in the 'Federal-gov' workclass category? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_604_1604140_qa_2/task.toml b/tasks/0001_604_1604140_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..0594eefb98a4b549bba8ec5431778c0abe201034 --- /dev/null +++ b/tasks/0001_604_1604140_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-eval-v1/0001_604_1604140_qa_2" +description = "Which U.S. state has the highest number of recorded mass shootings between 2010 and 2017 according to the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/604/1604140.ipynb_qa_2" +kaggle_dataset_name = "zusmani/us-mass-shootings-last-50-years" +gold_answer = "California" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zusmani__us-mass-shootings-last-50-years" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zusmani/us-mass-shootings-last-50-years" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "California" +QUESTION = "Which U.S. state has the highest number of recorded mass shootings between 2010 and 2017 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_903_1903160_qa_2/instruction.md b/tasks/0001_903_1903160_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..59b38ab4631c6decc9c1bb858f5af08efce4f6bf --- /dev/null +++ b/tasks/0001_903_1903160_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- cereal.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which nutritional attribute in the dataset has the highest coefficient of variation (standard deviation relative to the mean)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0001_903_1903160_qa_2/task.toml b/tasks/0001_903_1903160_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a13f425027e178305c04b49a862a71134728cd77 --- /dev/null +++ b/tasks/0001_903_1903160_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0001_903_1903160_qa_2" +description = "Which nutritional attribute in the dataset has the highest coefficient of variation (standard deviation relative to the mean)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0001/903/1903160.ipynb_qa_2" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "fiber" +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 = "crawford__80-cereals" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "crawford/80-cereals" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "fiber" +QUESTION = "Which nutritional attribute in the dataset has the highest coefficient of variation (standard deviation relative to the mean)?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0010_637_10637554_qa_1/task.toml b/tasks/0010_637_10637554_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..885c534da7306dcbb9592e8731103b4184b9e9a7 --- /dev/null +++ b/tasks/0010_637_10637554_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0010_637_10637554_qa_1" +description = "Which wine taster provided the highest average rating score in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0010/637/10637554.ipynb_qa_1" +kaggle_dataset_name = "zynicide/wine-reviews" +gold_answer = "Anne Krebiehl MW" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "zynicide__wine-reviews" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "zynicide/wine-reviews" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Anne Krebiehl MW" +QUESTION = "Which wine taster provided the highest average rating score 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/0011_544_11544512_qa_4/instruction.md b/tasks/0011_544_11544512_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c7a97c5f0cff1714272271ee84ae39f8b9110884 --- /dev/null +++ b/tasks/0011_544_11544512_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): +- housing.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 derived `num_rooms` feature (total rooms per household) 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/0011_544_11544512_qa_4/task.toml b/tasks/0011_544_11544512_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d9c02efd61eea402cc4a5180f6feeca3e1beb319 --- /dev/null +++ b/tasks/0011_544_11544512_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0011_544_11544512_qa_4" +description = "What is the mean value of the derived `num_rooms` feature (total rooms per household) in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0011/544/11544512.ipynb_qa_4" +kaggle_dataset_name = "anuvrat29/california-housing-value" +gold_answer = "5.4" +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 = "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.4" +QUESTION = "What is the mean value of the derived `num_rooms` feature (total rooms per household) 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/0021_389_21389737_qa_4/instruction.md b/tasks/0021_389_21389737_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5ae04742fa68a453d658b2ec8a9fead591aaf6a9 --- /dev/null +++ b/tasks/0021_389_21389737_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Life Expectancy Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which South American country had the highest life expectancy in 2015 according to the cleaned dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0021_389_21389737_qa_4/task.toml b/tasks/0021_389_21389737_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bc594808d6ffbb7e2884fc9c53dd79d1edcf213e --- /dev/null +++ b/tasks/0021_389_21389737_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0021_389_21389737_qa_4" +description = "Which South American country had the highest life expectancy in 2015 according to the cleaned dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0021/389/21389737.ipynb_qa_4" +kaggle_dataset_name = "kumarajarshi/life-expectancy-who" +gold_answer = "Chile" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "kumarajarshi__life-expectancy-who" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Chile" +QUESTION = "Which South American country had the highest life expectancy in 2015 according to the cleaned dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0026_947_26947069_qa_5/instruction.md b/tasks/0026_947_26947069_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3813bd6e751076ae4998e94b1695cb40faf0fdbd --- /dev/null +++ b/tasks/0026_947_26947069_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): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the maximum value of the charges variable after applying MinMaxScaler with the range [3, 7]? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_947_26947069_qa_5/task.toml b/tasks/0026_947_26947069_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..847e2d3b82e218438eb1eea443a066b0d905773a --- /dev/null +++ b/tasks/0026_947_26947069_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0026_947_26947069_qa_5" +description = "What is the maximum value of the charges variable after applying MinMaxScaler with the range [3, 7]?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0026/947/26947069.ipynb_qa_5" +kaggle_dataset_name = "mirichoi0218/insurance" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "7" +QUESTION = "What is the maximum value of the charges variable after applying MinMaxScaler with the range [3, 7]?" +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_184_29184728_qa_1/instruction.md b/tasks/0029_184_29184728_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..905c862afe6f79f7198bb724b40fea12db72681e --- /dev/null +++ b/tasks/0029_184_29184728_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 species of iris has the highest average sepal width 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/0033_558_33558610_qa_3/instruction.md b/tasks/0033_558_33558610_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..80e9d61beeb31cecf9c603b29fc633738b35d799 --- /dev/null +++ b/tasks/0033_558_33558610_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): +- flavors_of_cacao.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Based on the boxplot analysis, does non-domestic chocolate receive statistically significantly higher median ratings compared to domestic chocolate? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_558_33558610_qa_3/task.toml b/tasks/0033_558_33558610_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c02f6ba41f4bbc032ed6f32a5a2dd2a95fd7b78b --- /dev/null +++ b/tasks/0033_558_33558610_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0033_558_33558610_qa_3" +description = "Based on the boxplot analysis, does non-domestic chocolate receive statistically significantly higher median ratings compared to domestic chocolate?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0033/558/33558610.ipynb_qa_3" +kaggle_dataset_name = "rtatman/chocolate-bar-ratings" +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 = "rtatman__chocolate-bar-ratings" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rtatman/chocolate-bar-ratings" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "yes" +QUESTION = "Based on the boxplot analysis, does non-domestic chocolate receive statistically significantly higher median ratings compared to domestic chocolate?" +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_785_40785152_qa_2/instruction.md b/tasks/0040_785_40785152_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..11e8776549a5ed170151af5323e05ee916f987be --- /dev/null +++ b/tasks/0040_785_40785152_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 interquartile range (IQR) for the 'total sulfur dioxide' 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/0040_785_40785152_qa_2/task.toml b/tasks/0040_785_40785152_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..40906a86ed4fc83a548e973d951f5266fee249ba --- /dev/null +++ b/tasks/0040_785_40785152_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0040_785_40785152_qa_2" +description = "What is the interquartile range (IQR) for the 'total sulfur dioxide' feature?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0040/785/40785152.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "40" +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__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 = "40" +QUESTION = "What is the interquartile range (IQR) for the 'total sulfur dioxide' feature?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_324_41324781_qa_2/instruction.md b/tasks/0041_324_41324781_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..963511f23b0a0b3a04376820120725b8c0e8b59b --- /dev/null +++ b/tasks/0041_324_41324781_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): +- Social_Network_Ads.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of individuals in the dataset who did not purchase the product (Purchased=0)? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0041_324_41324781_qa_2/task.toml b/tasks/0041_324_41324781_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..6184ca3ef0a43360bc45279d704afd36a6143f00 --- /dev/null +++ b/tasks/0041_324_41324781_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0041_324_41324781_qa_2" +description = "What is the percentage of individuals in the dataset who did not purchase the product (Purchased=0)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/324/41324781.ipynb_qa_2" +kaggle_dataset_name = "rakeshrau/social-network-ads" +gold_answer = "64.25" +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 = "rakeshrau__social-network-ads" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "rakeshrau/social-network-ads" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "64.25" +QUESTION = "What is the percentage of individuals in the dataset who did not purchase the product (Purchased=0)?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0041_501_41501839_qa_5/instruction.md b/tasks/0041_501_41501839_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..7100361a0b881b644b3741d48a143a25c6db0990 --- /dev/null +++ b/tasks/0041_501_41501839_qa_5/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many missing values were imputed in the BloodPressure column after replacing zeroes with NaN? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that 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_501_41501839_qa_5/task.toml b/tasks/0041_501_41501839_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3bf327e1d2e128461402bd0893532cb62c92a84b --- /dev/null +++ b/tasks/0041_501_41501839_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0041_501_41501839_qa_5" +description = "How many missing values were imputed in the BloodPressure column after replacing zeroes with NaN?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0041/501/41501839.ipynb_qa_5" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "35" +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__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 = "35" +QUESTION = "How many missing values were imputed in the BloodPressure column after replacing zeroes with NaN?" +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_973_42973076_qa_4/instruction.md b/tasks/0042_973_42973076_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1b66dde4c25c27d700bbeb13e8f17aebed31a0d0 --- /dev/null +++ b/tasks/0042_973_42973076_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 median petal width for Iris-versicolor 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/0042_973_42973076_qa_4/task.toml b/tasks/0042_973_42973076_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..a8c918284f27760a5c502eda139d42b054c71aed --- /dev/null +++ b/tasks/0042_973_42973076_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0042_973_42973076_qa_4" +description = "What is the median petal width for Iris-versicolor species in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0042/973/42973076.ipynb_qa_4" +kaggle_dataset_name = "uciml/iris" +gold_answer = "1.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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1.3" +QUESTION = "What is the median petal width for Iris-versicolor 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/0043_551_43551294_qa_3/instruction.md b/tasks/0043_551_43551294_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..9b8a0985786cfe42ebcbe2a75526be193ba997e4 --- /dev/null +++ b/tasks/0043_551_43551294_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): +- diabetes.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature had the highest number of missing values after replacing zeros with NaN, and how many missing entries did it have? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, feature name 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/0043_551_43551294_qa_3/task.toml b/tasks/0043_551_43551294_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c84016d97f169c48757d61e9d3f4c6d742b3daaf --- /dev/null +++ b/tasks/0043_551_43551294_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0043_551_43551294_qa_3" +description = "Which feature had the highest number of missing values after replacing zeros with NaN, and how many missing entries did it have?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0043/551/43551294.ipynb_qa_3" +kaggle_dataset_name = "uciml/pima-indians-diabetes-database" +gold_answer = "Insulin, 374" +reward_mode_initial = "list" +package_tier = 2 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__pima-indians-diabetes-database" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/pima-indians-diabetes-database" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Insulin, 374" +QUESTION = "Which feature had the highest number of missing values after replacing zeros with NaN, and how many missing entries did it have?" +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/0044_367_44367279_qa_2/instruction.md b/tasks/0044_367_44367279_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b8b42770cffd5339c9aeecf1949aeadbcf38ad43 --- /dev/null +++ b/tasks/0044_367_44367279_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 average tenure (in months) of customers 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/0044_367_44367279_qa_2/task.toml b/tasks/0044_367_44367279_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..c44bc2f3bbad5b2d3bedbb625454879331403710 --- /dev/null +++ b/tasks/0044_367_44367279_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0044_367_44367279_qa_2" +description = "What is the average tenure (in months) of customers in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0044/367/44367279.ipynb_qa_2" +kaggle_dataset_name = "blastchar/telco-customer-churn" +gold_answer = "32.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 = "blastchar__telco-customer-churn" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "blastchar/telco-customer-churn" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "32.37" +QUESTION = "What is the average tenure (in months) of customers in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0046_035_46035466_qa_1/instruction.md b/tasks/0046_035_46035466_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..82d9e8afbc64fa6bf646aae24edaf94aa0fe235b --- /dev/null +++ b/tasks/0046_035_46035466_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the optimal number of clusters (k) determined by the elbow method in the K-means clustering 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/0046_035_46035466_qa_1/task.toml b/tasks/0046_035_46035466_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..87be6a7f233af40cc27cf0154369cd294272c624 --- /dev/null +++ b/tasks/0046_035_46035466_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0046_035_46035466_qa_1" +description = "What is the optimal number of clusters (k) determined by the elbow method in the K-means clustering analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0046/035/46035466.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "3" +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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "What is the optimal number of clusters (k) determined by the elbow method in the K-means clustering analysis?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0046_808_46808200_qa_4/instruction.md b/tasks/0046_808_46808200_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..1d8bf8cb24abb3d2666718a595e85c062e8b4725 --- /dev/null +++ b/tasks/0046_808_46808200_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): +- CC GENERAL.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 'CREDIT_LIMIT' column before imputation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0046_808_46808200_qa_4/task.toml b/tasks/0046_808_46808200_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..949bb0c5c7d77fb22c2c5e267bad65b71f7268ce --- /dev/null +++ b/tasks/0046_808_46808200_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0046_808_46808200_qa_4" +description = "How many missing values were present in the 'CREDIT_LIMIT' column before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0046/808/46808200.ipynb_qa_4" +kaggle_dataset_name = "arjunbhasin2013/ccdata" +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 = "arjunbhasin2013__ccdata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "arjunbhasin2013/ccdata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1" +QUESTION = "How many missing values were present in the 'CREDIT_LIMIT' column before imputation?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0046_857_46857117_qa_4/instruction.md b/tasks/0046_857_46857117_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3db549550137bcacd42ed8f0a15721bb3f216fc1 --- /dev/null +++ b/tasks/0046_857_46857117_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): +- Family Income and Expenditure.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many distinct simplified education attainment categories were created for the classification task? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0046_857_46857117_qa_4/task.toml b/tasks/0046_857_46857117_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..865bee10b0ce522cff971f2516676117857fc5c9 --- /dev/null +++ b/tasks/0046_857_46857117_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0046_857_46857117_qa_4" +description = "How many distinct simplified education attainment categories were created for the classification task?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0046/857/46857117.ipynb_qa_4" +kaggle_dataset_name = "grosvenpaul/family-income-and-expenditure" +gold_answer = "5" +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 = "grosvenpaul__family-income-and-expenditure" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "grosvenpaul/family-income-and-expenditure" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5" +QUESTION = "How many distinct simplified education attainment categories were created for the classification task?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0049_677_49677120_qa_1/instruction.md b/tasks/0049_677_49677120_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5e7feaca9b13e8384c3b0e4ee1bb7238e9bb0140 --- /dev/null +++ b/tasks/0049_677_49677120_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which physicochemical characteristic is identified as the most important predictor of wine quality according to the Random Forest model's 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/0049_677_49677120_qa_1/task.toml b/tasks/0049_677_49677120_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..5dd4719aac1d058ceb27f8faf517d198b05d2f8d --- /dev/null +++ b/tasks/0049_677_49677120_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0049_677_49677120_qa_1" +description = "Which physicochemical characteristic is identified as the most important predictor of wine quality according to the Random Forest model's feature importance analysis?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0049/677/49677120.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "Alcohol" +reward_mode_initial = "exact_short" +package_tier = 1 +difficulty_level = 4 +difficulty_tier = "hard" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Alcohol" +QUESTION = "Which physicochemical characteristic is identified as the most important predictor of wine quality according to the Random Forest model's 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/0050_233_50233728_qa_5/instruction.md b/tasks/0050_233_50233728_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6bc65f990a02bf83d3e15011b9e0fbfffd475ec5 --- /dev/null +++ b/tasks/0050_233_50233728_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): +- 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 pH value observed in the wine 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/0050_233_50233728_qa_5/task.toml b/tasks/0050_233_50233728_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..28e2aac1a24e8ffbf80fd27ef3b1e26e2b1ccc20 --- /dev/null +++ b/tasks/0050_233_50233728_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0050_233_50233728_qa_5" +description = "What is the median pH value observed in the wine dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0050/233/50233728.ipynb_qa_5" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "3.31" +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__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 = "3.31" +QUESTION = "What is the median pH value observed in the wine 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/0057_712_57712524_qa_2/instruction.md b/tasks/0057_712_57712524_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3896ca3241d64be42ad1d57800c0f9a5fde0d752 --- /dev/null +++ b/tasks/0057_712_57712524_qa_2/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many wines are classified as 'good' in the transformed dataset after applying the quality score threshold? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0057_712_57712524_qa_2/task.toml b/tasks/0057_712_57712524_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..209df82333e309e0c71b8f892c24778a8d116e92 --- /dev/null +++ b/tasks/0057_712_57712524_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0057_712_57712524_qa_2" +description = "How many wines are classified as 'good' in the transformed dataset after applying the quality score threshold?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0057/712/57712524.ipynb_qa_2" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "217" +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__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 = "217" +QUESTION = "How many wines are classified as 'good' in the transformed dataset after applying the quality score threshold?" +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/0061_770_61770230_qa_3/instruction.md b/tasks/0061_770_61770230_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..8a8833c65ff68c9872767d55045f722a8049e6fb --- /dev/null +++ b/tasks/0061_770_61770230_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): +- tmdb_5000_movies.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which movie has the highest weighted score according to the calculated metric? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0061_770_61770230_qa_3/task.toml b/tasks/0061_770_61770230_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..798be169b09a9dc5dbeb20baa36de6dfd03ea41b --- /dev/null +++ b/tasks/0061_770_61770230_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0061_770_61770230_qa_3" +description = "Which movie has the highest weighted score according to the calculated metric?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0061/770/61770230.ipynb_qa_3" +kaggle_dataset_name = "tmdb/tmdb-movie-metadata" +gold_answer = "The Shawshank Redemption" +reward_mode_initial = "exact_short" +package_tier = 0 +difficulty_level = 3 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "tmdb__tmdb-movie-metadata" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "tmdb/tmdb-movie-metadata" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "The Shawshank Redemption" +QUESTION = "Which movie has the highest weighted score according to the calculated metric?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0066_134_66134404_qa_1/instruction.md b/tasks/0066_134_66134404_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..bcce3663682acac37b4f08eee8190ec60723fb93 --- /dev/null +++ b/tasks/0066_134_66134404_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): +- Life Expectancy Data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which three features had the highest missing value percentages in the original dataset before imputation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as a comma-separated list of the three 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/0066_134_66134404_qa_1/task.toml b/tasks/0066_134_66134404_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..893743b9da5889255fde0170376fc4dc80d9142e --- /dev/null +++ b/tasks/0066_134_66134404_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0066_134_66134404_qa_1" +description = "Which three features had the highest missing value percentages in the original dataset before imputation?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0066/134/66134404.ipynb_qa_1" +kaggle_dataset_name = "kumarajarshi/life-expectancy-who" +gold_answer = "Population, Hepatitis B, GDP" +reward_mode_initial = "list" +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 = "kumarajarshi__life-expectancy-who" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "kumarajarshi/life-expectancy-who" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "Population, Hepatitis B, GDP" +QUESTION = "Which three features had the highest missing value percentages in the original dataset before imputation?" +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/0068_984_68984398_qa_4/instruction.md b/tasks/0068_984_68984398_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..5af7644196441c9dfc1a1848c559ba883939e5eb --- /dev/null +++ b/tasks/0068_984_68984398_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- data.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +How many data samples are present in the dataset after removing the id and Unnamed: 32 columns? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0068_984_68984398_qa_4/task.toml b/tasks/0068_984_68984398_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b332fa6a421b2e9c27e6e9ac1406e3b47023056d --- /dev/null +++ b/tasks/0068_984_68984398_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0068_984_68984398_qa_4" +description = "How many data samples are present in the dataset after removing the id and Unnamed: 32 columns?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0068/984/68984398.ipynb_qa_4" +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 data samples are present in the dataset after removing the id and Unnamed: 32 columns?" +REWARD_MODE = "numeric" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0072_066_72066220_qa_1/instruction.md b/tasks/0072_066_72066220_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a489d263732b411decd632350f619cf7d3422dc1 --- /dev/null +++ b/tasks/0072_066_72066220_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the optimal number of clusters determined by the Elbow method 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/0072_066_72066220_qa_1/task.toml b/tasks/0072_066_72066220_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..536bcc77fe6e8a81e1304ce7216b187213651a97 --- /dev/null +++ b/tasks/0072_066_72066220_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0072_066_72066220_qa_1" +description = "What is the optimal number of clusters determined by the Elbow method in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0072/066/72066220.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "3" +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 = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "3" +QUESTION = "What is the optimal number of clusters determined by the Elbow method 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/0072_108_72108430_qa_3/instruction.md b/tasks/0072_108_72108430_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4c3f19b4d4162101369cb5b37863bbe5389cc288 --- /dev/null +++ b/tasks/0072_108_72108430_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the median sepal length across all 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/0072_108_72108430_qa_3/task.toml b/tasks/0072_108_72108430_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..d416b306d497b1b77068b9f12ce737a3bd902713 --- /dev/null +++ b/tasks/0072_108_72108430_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0072_108_72108430_qa_3" +description = "What is the median sepal length across all species in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0072/108/72108430.ipynb_qa_3" +kaggle_dataset_name = "uciml/iris" +gold_answer = "5.8" +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__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "5.8" +QUESTION = "What is the median sepal length across all 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/0074_290_74290093_qa_1/instruction.md b/tasks/0074_290_74290093_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c62b4758b6ec18016895aa8ffc831f56e1d08702 --- /dev/null +++ b/tasks/0074_290_74290093_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the most frequent wine quality rating in the training set after removing duplicated rows? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0074_290_74290093_qa_1/task.toml b/tasks/0074_290_74290093_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..635004a96dc797b529972351379653853ddadc36 --- /dev/null +++ b/tasks/0074_290_74290093_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0074_290_74290093_qa_1" +description = "What is the most frequent wine quality rating in the training set after removing duplicated rows?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/290/74290093.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "5" +reward_mode_initial = "numeric" +package_tier = 1 +difficulty_level = 2 +difficulty_tier = "medium" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "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 = "5" +QUESTION = "What is the most frequent wine quality rating in the training set after removing duplicated rows?" +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/0074_467_74467849_qa_2/instruction.md b/tasks/0074_467_74467849_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..6567558a91d333e36bcfd55c6caa7875208e4e20 --- /dev/null +++ b/tasks/0074_467_74467849_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): +- student-mat.csv +- student-por.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the percentage of students from MS school in the Math class? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0074_467_74467849_qa_2/task.toml b/tasks/0074_467_74467849_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..18254d8c9ed439601e453a4eaa499b331c59b16f --- /dev/null +++ b/tasks/0074_467_74467849_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0074_467_74467849_qa_2" +description = "What is the percentage of students from MS school in the Math class?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0074/467/74467849.ipynb_qa_2" +kaggle_dataset_name = "uciml/student-alcohol-consumption" +gold_answer = "11.65" +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__student-alcohol-consumption" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/student-alcohol-consumption" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "11.65" +QUESTION = "What is the percentage of students from MS school in the Math class?" +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/0082_385_82385327_qa_3/instruction.md b/tasks/0082_385_82385327_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..3cece77a099ff34840915978b0abca0cf6c88b10 --- /dev/null +++ b/tasks/0082_385_82385327_qa_3/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- vgsales.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which year saw the release of the first game in the dataset to exceed 10,000 units in sales? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0082_385_82385327_qa_3/task.toml b/tasks/0082_385_82385327_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..8773c96c02f9ba24d714cb4bd14ec64a90958f73 --- /dev/null +++ b/tasks/0082_385_82385327_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0082_385_82385327_qa_3" +description = "Which year saw the release of the first game in the dataset to exceed 10,000 units in sales?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0082/385/82385327.ipynb_qa_3" +kaggle_dataset_name = "gregorut/videogamesales" +gold_answer = "1980" +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 = "gregorut__videogamesales" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "gregorut/videogamesales" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "1980" +QUESTION = "Which year saw the release of the first game in the dataset to exceed 10,000 units in sales?" +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/0083_022_83022280_qa_3/instruction.md b/tasks/0083_022_83022280_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..4727d5d747edd8ee9c6bc7c56e41116bd78388eb --- /dev/null +++ b/tasks/0083_022_83022280_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): +- Iris.csv +- database.sqlite + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What percentage of the dataset was allocated to the test set during the train-test split for model evaluation? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0084_135_84135613_qa_1/instruction.md b/tasks/0084_135_84135613_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d156c8ffd27d7e5a5016b54ba2c2799188ee2130 --- /dev/null +++ b/tasks/0084_135_84135613_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): +- covtype.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +What is the highest absolute correlation coefficient between any two features in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0084_135_84135613_qa_1/task.toml b/tasks/0084_135_84135613_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b0024a5daba3f3dbdda21de0dc899c05c180a523 --- /dev/null +++ b/tasks/0084_135_84135613_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "data-agent-train-v1/0084_135_84135613_qa_1" +description = "What is the highest absolute correlation coefficient between any two features in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/135/84135613.ipynb_qa_1" +kaggle_dataset_name = "uciml/forest-cover-type-dataset" +gold_answer = "0.79" +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 = "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 = "0.79" +QUESTION = "What is the highest absolute correlation coefficient between any two features in the dataset?" +REWARD_MODE = "numeric" +ATOL = "0.05" +RTOL = "0.01" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0084_148_84148842_qa_5/instruction.md b/tasks/0084_148_84148842_qa_5/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..199543b28d83dec712dc92a39d0253a9e535748d --- /dev/null +++ b/tasks/0084_148_84148842_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 range of cereal ratings in the dataset (difference between maximum and minimum 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/0084_148_84148842_qa_5/task.toml b/tasks/0084_148_84148842_qa_5/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..b35caaf9064cfe7fca7765f6352ce1131a4acb91 --- /dev/null +++ b/tasks/0084_148_84148842_qa_5/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0084_148_84148842_qa_5" +description = "What is the range of cereal ratings in the dataset (difference between maximum and minimum values)?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/148/84148842.ipynb_qa_5" +kaggle_dataset_name = "crawford/80-cereals" +gold_answer = "75.66" +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.66" +QUESTION = "What is the range of cereal ratings in the dataset (difference between maximum and minimum 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/0084_821_84821146_qa_1/instruction.md b/tasks/0084_821_84821146_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..d9425c5ea5cd101f6ed73387eb78a3e00295c587 --- /dev/null +++ b/tasks/0084_821_84821146_qa_1/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- winequality-red.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature exhibits the highest positive correlation with wine quality 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/0084_821_84821146_qa_1/task.toml b/tasks/0084_821_84821146_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..bd20af593ccf2f461aa5d710445c8676ea4c9a29 --- /dev/null +++ b/tasks/0084_821_84821146_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0084_821_84821146_qa_1" +description = "Which feature exhibits the highest positive correlation with wine quality in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0084/821/84821146.ipynb_qa_1" +kaggle_dataset_name = "uciml/red-wine-quality-cortez-et-al-2009" +gold_answer = "alcohol" +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__red-wine-quality-cortez-et-al-2009" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/red-wine-quality-cortez-et-al-2009" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "alcohol" +QUESTION = "Which feature exhibits the highest positive correlation with wine quality 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/0089_255_89255842_qa_4/instruction.md b/tasks/0089_255_89255842_qa_4/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..c50f58efe64df7f674b101f9a829ca1ad224556f --- /dev/null +++ b/tasks/0089_255_89255842_qa_4/instruction.md @@ -0,0 +1,15 @@ +You are a data-analysis agent working in a sandbox. Use your code-execution tool to inspect the files and compute the answer. + +Files (in /home/user/input, no subfolders): +- insurance.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature has the least statistical relevance to insurance charges based on the SelectKBest f_regression scores? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0089_255_89255842_qa_4/task.toml b/tasks/0089_255_89255842_qa_4/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..3de9b54f39e6425a0d358d60f1d68127f6a2e43d --- /dev/null +++ b/tasks/0089_255_89255842_qa_4/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0089_255_89255842_qa_4" +description = "Which feature has the least statistical relevance to insurance charges based on the SelectKBest f_regression scores?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0089/255/89255842.ipynb_qa_4" +kaggle_dataset_name = "mirichoi0218/insurance" +gold_answer = "region" +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 = "mirichoi0218__insurance" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "mirichoi0218/insurance" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "region" +QUESTION = "Which feature has the least statistical relevance to insurance charges based on the SelectKBest f_regression scores?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0090_629_90629430_qa_1/instruction.md b/tasks/0090_629_90629430_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..0e3f221fc9e41ac8f05c4a94fd7986297138e483 --- /dev/null +++ b/tasks/0090_629_90629430_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): +- bank.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which job category has the highest number of clients who did not subscribe to the term deposit? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0090_629_90629430_qa_1/task.toml b/tasks/0090_629_90629430_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..957377b5794500fac87bcb7e1e30c7119430ec4c --- /dev/null +++ b/tasks/0090_629_90629430_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0090_629_90629430_qa_1" +description = "Which job category has the highest number of clients who did not subscribe to the term deposit?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0090/629/90629430.ipynb_qa_1" +kaggle_dataset_name = "janiobachmann/bank-marketing-dataset" +gold_answer = "blue-collar" +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 = "janiobachmann__bank-marketing-dataset" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "janiobachmann/bank-marketing-dataset" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "blue-collar" +QUESTION = "Which job category has the highest number of clients who did not subscribe to the term deposit?" +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/0096_973_96973759_qa_3/instruction.md b/tasks/0096_973_96973759_qa_3/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..b105bbc06becc802b47e35dc6a25fcd0f2fcffa2 --- /dev/null +++ b/tasks/0096_973_96973759_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): +- spam.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which classification model achieves higher accuracy on the test set: Multinomial Naive Bayes or Logistic Regression? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0096_973_96973759_qa_3/task.toml b/tasks/0096_973_96973759_qa_3/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..2f0e14a34a36305cb565ef9906fd97a445b195b1 --- /dev/null +++ b/tasks/0096_973_96973759_qa_3/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0096_973_96973759_qa_3" +description = "Which classification model achieves higher accuracy on the test set: Multinomial Naive Bayes or Logistic Regression?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0096/973/96973759.ipynb_qa_3" +kaggle_dataset_name = "uciml/sms-spam-collection-dataset" +gold_answer = "Logistic Regression" +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 = "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 = "Logistic Regression" +QUESTION = "Which classification model achieves higher accuracy on the test set: Multinomial Naive Bayes or Logistic Regression?" +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/0108_363_108363990_qa_1/instruction.md b/tasks/0108_363_108363990_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..a16ca1b2715537972e27929d8d1bd7364ffd4908 --- /dev/null +++ b/tasks/0108_363_108363990_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 outliers are identified in the 'price' variable using the interquartile range (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/0108_363_108363990_qa_1/task.toml b/tasks/0108_363_108363990_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..be9c58ec4f2b97950d1dc834ce92050f1e64f37e --- /dev/null +++ b/tasks/0108_363_108363990_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0108_363_108363990_qa_1" +description = "How many outliers are identified in the 'price' variable using the interquartile range (IQR) method?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0108/363/108363990.ipynb_qa_1" +kaggle_dataset_name = "ananthreddy/housing" +gold_answer = "15" +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 = "ananthreddy__housing" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "ananthreddy/housing" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "15" +QUESTION = "How many outliers are identified in the 'price' variable using the interquartile range (IQR) method?" +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/0114_944_114944895_qa_1/instruction.md b/tasks/0114_944_114944895_qa_1/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..126e0a60a166fb979a7dc2ea58af816366812679 --- /dev/null +++ b/tasks/0114_944_114944895_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): +- Iris.csv + +Installed: pandas, numpy, matplotlib, seaborn, scipy, scikit-learn, statsmodels, tabulate, sqlite3, plotly (pip install more if needed). + +Question: +Which feature (excluding the Species column) has the highest standard deviation in the dataset, and what is the value? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer as: , (comma-separated, feature name first, keep decimals). + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0114_944_114944895_qa_1/task.toml b/tasks/0114_944_114944895_qa_1/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..52398774347ae3c5c3d1e771c27a933160cc666a --- /dev/null +++ b/tasks/0114_944_114944895_qa_1/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify/0114_944_114944895_qa_1" +description = "Which feature (excluding the Species column) has the highest standard deviation in the dataset, and what is the value?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0114/944/114944895.ipynb_qa_1" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalLengthCm, 1.764" +reward_mode_initial = "list" +package_tier = 2 +difficulty_level = 1 +difficulty_tier = "easy" + +[environment] +build_timeout_sec = 600.0 +os = "linux" +cpus = 1 +memory_mb = 1024 +storage_mb = 5120 +gpus = 0 +allow_internet = true +mcp_servers = [] + +# Pre-agent hook: Harbor runs the command AFTER container start and BEFORE the +# agent setup begins. We use it to pull this task's bucket prefix into +# /home/user/input/. See environment/pull_bucket.py. +[environment.healthcheck] +command = "python3 /opt/pull_bucket.py && [ -n \"$(ls /home/user/input)\" ]" +interval_sec = 2.0 +timeout_sec = 180.0 +start_period_sec = 5.0 +start_interval_sec = 2.0 +retries = 30 + +[environment.env] +HF_BUCKET = "AdithyaSK/jupyter-agent-kaggle-all" +BUCKET_PREFIX = "uciml__iris" +HF_TOKEN = "${HF_TOKEN}" +KAGGLE_DATASET_NAME = "uciml/iris" + +[verifier] +timeout_sec = 120.0 + +[verifier.env] +EXPECTED_ANSWER = "PetalLengthCm, 1.764" +QUESTION = "Which feature (excluding the Species column) has the highest standard deviation in the dataset, and what is the value?" +REWARD_MODE = "flexible" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env] diff --git a/tasks/0128_954_128954233_qa_2/instruction.md b/tasks/0128_954_128954233_qa_2/instruction.md new file mode 100644 index 0000000000000000000000000000000000000000..497055a90339cbdd60d64f59a5cd5b688ee7a991 --- /dev/null +++ b/tasks/0128_954_128954233_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: +Which feature has the strongest positive correlation with the Iris-virginica species dummy variable in the dataset? + +Work it out step by step — inspect the data first (head, shape, dtypes), then compute. + +Answer with a single clean value: a bare number (no commas or units, e.g. 95293), a short label, yes/no, or a comma-separated list. Keep decimal precision. If there's no applicable answer, write: Not Applicable + +Write only that value to /workdir/answer.txt (e.g. `echo -n "" > /workdir/answer.txt`), then stop. \ No newline at end of file diff --git a/tasks/0128_954_128954233_qa_2/task.toml b/tasks/0128_954_128954233_qa_2/task.toml new file mode 100644 index 0000000000000000000000000000000000000000..dde70fd440d3fa9f06b67bba42da0a22a195fe42 --- /dev/null +++ b/tasks/0128_954_128954233_qa_2/task.toml @@ -0,0 +1,64 @@ +schema_version = "1.2" +artifacts = [] + +[task] +name = "train-verify2/0128_954_128954233_qa_2" +description = "Which feature has the strongest positive correlation with the Iris-virginica species dummy variable in the dataset?" +authors = [] +keywords = ["data-agent", "data-analysis", "kaggle"] + +[metadata] +source_dataset = "jupyter-agent/jupyter-agent-dataset" +source_row_id = "0128/954/128954233.ipynb_qa_2" +kaggle_dataset_name = "uciml/iris" +gold_answer = "PetalWidthCm" +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 = "PetalWidthCm" +QUESTION = "Which feature has the strongest positive correlation with the Iris-virginica species dummy variable in the dataset?" +REWARD_MODE = "exact_short" +ATOL = "0.0" +RTOL = "0.0" + +[agent] +# Capped at 600s (10 min) to kill the long-tail stuck-agent cases without +# cutting off legitimate complex trials. Median Phase B trial is 60-120s; +# legitimate L4/L5 tasks can hit 200-300s; anything past 600s is almost +# certainly a stuck agent loop. +timeout_sec = 600.0 + +[solution.env]