diff --git a/foundational_analysis/cases/case01/case01_01.json b/foundational_analysis/cases/case01/case01_01.json new file mode 100644 index 0000000000000000000000000000000000000000..34fb851d422ec91ce06dc9819c174dd5f26933dc --- /dev/null +++ b/foundational_analysis/cases/case01/case01_01.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 11.81567963841674, + "tolerance": 1.181567963841674 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_02.json b/foundational_analysis/cases/case01/case01_02.json new file mode 100644 index 0000000000000000000000000000000000000000..0c279932e97ae3dbd68a71a37a5fcf900e003782 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_02.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_02.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 9.26960186255792, + "tolerance": 0.926960186255792 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_03.json b/foundational_analysis/cases/case01/case01_03.json new file mode 100644 index 0000000000000000000000000000000000000000..9e5ff1661c5a1f1e75ad7a6ecacd0a0c8224844f --- /dev/null +++ b/foundational_analysis/cases/case01/case01_03.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_03.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 11.932442037349787, + "tolerance": 1.1932442037349789 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_04.json b/foundational_analysis/cases/case01/case01_04.json new file mode 100644 index 0000000000000000000000000000000000000000..462b56eb9a283a62b26bc901b52cf7089983d24a --- /dev/null +++ b/foundational_analysis/cases/case01/case01_04.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_04.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 5.878455525394873, + "tolerance": 0.5878455525394873 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_05.json b/foundational_analysis/cases/case01/case01_05.json new file mode 100644 index 0000000000000000000000000000000000000000..90d6f444b50b7f185c627d02061d97d466b34b56 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_05.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_05.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 7.919897825685701, + "tolerance": 0.7919897825685701 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_06.json b/foundational_analysis/cases/case01/case01_06.json new file mode 100644 index 0000000000000000000000000000000000000000..8beaee0c075d6afc84f3465bcf2a4c28ceb46d86 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_06.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 13.560618171116563, + "tolerance": 1.3560624385726978 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_07.json b/foundational_analysis/cases/case01/case01_07.json new file mode 100644 index 0000000000000000000000000000000000000000..9cd3fd246814f9e3a34e5ecd0ee2d5eaf567af31 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_07.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_02.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 12.075784079421299, + "tolerance": 1.2075783110068763 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_08.json b/foundational_analysis/cases/case01/case01_08.json new file mode 100644 index 0000000000000000000000000000000000000000..91f44233e91f07f271f2c102afe00351651f0c02 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_08.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_03.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 12.149602175318517, + "tolerance": 1.2149599789598067 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_09.json b/foundational_analysis/cases/case01/case01_09.json new file mode 100644 index 0000000000000000000000000000000000000000..15014940263d6eb4d696b8dad645dd1b8ade6c35 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_09.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_04.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 14.652083592026083, + "tolerance": 1.4652082512405658 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_10.json b/foundational_analysis/cases/case01/case01_10.json new file mode 100644 index 0000000000000000000000000000000000000000..b2d8fe009b999a934ff560104d2a72cafbe6eeed --- /dev/null +++ b/foundational_analysis/cases/case01/case01_10.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_05.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 13.166214068045193, + "tolerance": 1.3166212097326537 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_11.json b/foundational_analysis/cases/case01/case01_11.json new file mode 100644 index 0000000000000000000000000000000000000000..ee8d11035faeb3a3a5242f97134df74c9027a94d --- /dev/null +++ b/foundational_analysis/cases/case01/case01_11.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 4.836610733624954, + "tolerance": 0.4836610733624954 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_12.json b/foundational_analysis/cases/case01/case01_12.json new file mode 100644 index 0000000000000000000000000000000000000000..0864974f423fe9720a360aa99d46d1257afdb9a0 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_12.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-02.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-02.cnt", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 6.833748557175907, + "tolerance": 0.6833748557175907 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_13.json b/foundational_analysis/cases/case01/case01_13.json new file mode 100644 index 0000000000000000000000000000000000000000..4ef18b9df34060ea6abdaae2b9cb68cd1345cba2 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_13.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-03.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-03.cnt", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 7.544371519964062, + "tolerance": 0.7544371519964063 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_14.json b/foundational_analysis/cases/case01/case01_14.json new file mode 100644 index 0000000000000000000000000000000000000000..ef786fe50a837dd0c73b1c5f4fd5c6640363608b --- /dev/null +++ b/foundational_analysis/cases/case01/case01_14.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-04.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-04.cnt", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 13.23650829225669, + "tolerance": 1.3236508292256692 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_15.json b/foundational_analysis/cases/case01/case01_15.json new file mode 100644 index 0000000000000000000000000000000000000000..8721039db0da5baa1034b6a4495236bcca686432 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_15.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-05.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-05.cnt", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 9.461418170390266, + "tolerance": 0.9461418170390266 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_16.json b/foundational_analysis/cases/case01/case01_16.json new file mode 100644 index 0000000000000000000000000000000000000000..913bccfe4b421f6ed064c4242c615094947c927a --- /dev/null +++ b/foundational_analysis/cases/case01/case01_16.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 25.60839634754504, + "tolerance": 2.560839634754504 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_17.json b/foundational_analysis/cases/case01/case01_17.json new file mode 100644 index 0000000000000000000000000000000000000000..71276bd0fb33a05782d915f2e2ea7664cc445382 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_17.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_02.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 26.963042816030004, + "tolerance": 2.6963042816030005 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_18.json b/foundational_analysis/cases/case01/case01_18.json new file mode 100644 index 0000000000000000000000000000000000000000..3a3dd28541820aa59be6a5417da67f51d34c7fd2 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_18.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_03.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 58.63472717305611, + "tolerance": 5.863472717305612 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_19.json b/foundational_analysis/cases/case01/case01_19.json new file mode 100644 index 0000000000000000000000000000000000000000..aeed29a23a2e1189c3c83a44b7c67009dc08e663 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_19.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_04.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 21.885057050117236, + "tolerance": 2.188505705011724 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_20.json b/foundational_analysis/cases/case01/case01_20.json new file mode 100644 index 0000000000000000000000000000000000000000..207a28f85862cfbd29a58b2f673287883034e0e3 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_20.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_05.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 36.11783061563106, + "tolerance": 3.6117830615631057 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_21.json b/foundational_analysis/cases/case01/case01_21.json new file mode 100644 index 0000000000000000000000000000000000000000..999030abff2ad84afb488731ae6e30964255af5d --- /dev/null +++ b/foundational_analysis/cases/case01/case01_21.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 41.33018074506845, + "tolerance": 4.133018074506846 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_22.json b/foundational_analysis/cases/case01/case01_22.json new file mode 100644 index 0000000000000000000000000000000000000000..03777bbf6203a32c6a5ce4879c9e590e14e39f57 --- /dev/null +++ b/foundational_analysis/cases/case01/case01_22.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_02.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 18.30015063387382, + "tolerance": 1.830015063387382 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_23.json b/foundational_analysis/cases/case01/case01_23.json new file mode 100644 index 0000000000000000000000000000000000000000..f6ff2dcdb3bc5901e2edbb8d71083f6b33253b7e --- /dev/null +++ b/foundational_analysis/cases/case01/case01_23.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_03.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 23.478518914155703, + "tolerance": 2.3478518914155706 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_24.json b/foundational_analysis/cases/case01/case01_24.json new file mode 100644 index 0000000000000000000000000000000000000000..ab0eed5ea01c9f60e3521173d64b957e1c73542d --- /dev/null +++ b/foundational_analysis/cases/case01/case01_24.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_04.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 40.95759770354007, + "tolerance": 4.0957597703540065 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case01/case01_25.json b/foundational_analysis/cases/case01/case01_25.json new file mode 100644 index 0000000000000000000000000000000000000000..49c7b9e62b597d8c8a191c07594596d62c83a87f --- /dev/null +++ b/foundational_analysis/cases/case01/case01_25.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_05.edf", + "instruction": "Please first extract only the EEG channels from the raw signal, and then apply a 0.5-40Hz FIR bandpass filter to these channels. After filtering, obtain each channel's Alpha-band power and total filtered-signal power by integrating the PSD over frequency. Calculate Alpha relative power separately for each channel, then average the channel-wise ratios and report the final percentage value clearly in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the 'Alpha Relative Power Percentage' from the agent's report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units (%).\n4. The Key in the JSON must be EXACTLY \"alpha_ratio\".\n5. The Value must be a FLOAT (e.g., if the report says 25.5%, output 25.5).\n6. If the value is missing or cannot be found, return {\"alpha_ratio\": null}.\n\n### OUTPUT TEMPLATE\n{\"alpha_ratio\": }", + "metrics": [ + { + "metric_id": "alpha_ratio_accuracy", + "type": "numeric_check", + "target_key": "alpha_ratio", + "weight": 100, + "params": { + "gt_value": 18.87056907818833, + "tolerance": 1.8870569078188328 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case02/case02_01.json b/foundational_analysis/cases/case02/case02_01.json new file mode 100644 index 0000000000000000000000000000000000000000..7cc73c724f25482ac71b7ee9491ab01ea8fd7845 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_01.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 2.344264, + "tolerance": 0.234426 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 3.603543, + "tolerance": 0.360354 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_02.json b/foundational_analysis/cases/case02/case02_02.json new file mode 100644 index 0000000000000000000000000000000000000000..92e0e0e49ee7b5653e4c8f222c39056a28108493 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_02.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_02.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.950857, + "tolerance": 0.095086 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.989856, + "tolerance": 0.098986 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_03.json b/foundational_analysis/cases/case02/case02_03.json new file mode 100644 index 0000000000000000000000000000000000000000..a21e481776636ac3842ca5f5c43459f94d1bccdf --- /dev/null +++ b/foundational_analysis/cases/case02/case02_03.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_03.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 1.168239, + "tolerance": 0.116824 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.684525, + "tolerance": 0.168453 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_04.json b/foundational_analysis/cases/case02/case02_04.json new file mode 100644 index 0000000000000000000000000000000000000000..bcf03a3f669380955fd74559ecb6c08b3fd6a243 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_04.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_04.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 1.161963, + "tolerance": 0.116196 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 2.076704, + "tolerance": 0.20767 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_05.json b/foundational_analysis/cases/case02/case02_05.json new file mode 100644 index 0000000000000000000000000000000000000000..84ac0626822fa0b8033cdbbb61489e706c362bcf --- /dev/null +++ b/foundational_analysis/cases/case02/case02_05.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_05.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.669702, + "tolerance": 0.06697 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.774508, + "tolerance": 0.077451 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_06.json b/foundational_analysis/cases/case02/case02_06.json new file mode 100644 index 0000000000000000000000000000000000000000..b9b1ab9bc2769483d781b079658a7279d90b0cd5 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_06.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.293048, + "tolerance": 0.029305 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.232857, + "tolerance": 0.023286 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_07.json b/foundational_analysis/cases/case02/case02_07.json new file mode 100644 index 0000000000000000000000000000000000000000..eda8bf4d9aa25534afd052ac06faa0c73f13d64a --- /dev/null +++ b/foundational_analysis/cases/case02/case02_07.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_02.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.323811, + "tolerance": 0.032381 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.202792, + "tolerance": 0.020279 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_08.json b/foundational_analysis/cases/case02/case02_08.json new file mode 100644 index 0000000000000000000000000000000000000000..a80d40f73de17b37f8f4c9a882b4e3c00c11bce9 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_08.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_03.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.264357, + "tolerance": 0.026436 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.244232, + "tolerance": 0.024423 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_09.json b/foundational_analysis/cases/case02/case02_09.json new file mode 100644 index 0000000000000000000000000000000000000000..2d0e653a5467ce53e2b1df39847fdfa195d9fce0 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_09.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_04.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.408242, + "tolerance": 0.040824 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.212913, + "tolerance": 0.021291 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_10.json b/foundational_analysis/cases/case02/case02_10.json new file mode 100644 index 0000000000000000000000000000000000000000..3c2d0d67df8d3a9e6b537830e342aaca6fe56ab9 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_10.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_05.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.184103, + "tolerance": 0.01841 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.181707, + "tolerance": 0.018171 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_11.json b/foundational_analysis/cases/case02/case02_11.json new file mode 100644 index 0000000000000000000000000000000000000000..4f3be6f718a3a5adbcb1de5f3cb1bc1c4e3a564c --- /dev/null +++ b/foundational_analysis/cases/case02/case02_11.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.372668, + "tolerance": 0.037267 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.702498, + "tolerance": 0.17025 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_12.json b/foundational_analysis/cases/case02/case02_12.json new file mode 100644 index 0000000000000000000000000000000000000000..e941a38cdb1ea9edd8fe8dd92ff16b3e7bd77966 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_12.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-02.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-02.cnt", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 1.048704, + "tolerance": 0.10487 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 2.825685, + "tolerance": 0.282569 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_13.json b/foundational_analysis/cases/case02/case02_13.json new file mode 100644 index 0000000000000000000000000000000000000000..d79441d0029cb6c3a370c560c1bbb4a09436af1d --- /dev/null +++ b/foundational_analysis/cases/case02/case02_13.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-03.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-03.cnt", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.618508, + "tolerance": 0.061851 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 2.884954, + "tolerance": 0.288495 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_14.json b/foundational_analysis/cases/case02/case02_14.json new file mode 100644 index 0000000000000000000000000000000000000000..8cc8a8aec1e6f83d5d8beb02d4076d39f34be853 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_14.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-04.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-04.cnt", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.826021, + "tolerance": 0.082602 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.513809, + "tolerance": 0.151381 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_15.json b/foundational_analysis/cases/case02/case02_15.json new file mode 100644 index 0000000000000000000000000000000000000000..ef52b4de76a0b9096a1700b36686740936698c76 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_15.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-05.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-05.cnt", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 1.554786, + "tolerance": 0.155479 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 7.43622, + "tolerance": 0.743622 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_16.json b/foundational_analysis/cases/case02/case02_16.json new file mode 100644 index 0000000000000000000000000000000000000000..51a0036b0d0657f6962b72477b01e476f04a7f7d --- /dev/null +++ b/foundational_analysis/cases/case02/case02_16.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.904181, + "tolerance": 0.090418 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.133355, + "tolerance": 0.113335 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_17.json b/foundational_analysis/cases/case02/case02_17.json new file mode 100644 index 0000000000000000000000000000000000000000..3ad438601daefc8d5b6c36a73b6e43d2ae2ea353 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_17.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_02.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 3.290876, + "tolerance": 0.329088 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.536704, + "tolerance": 0.15367 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_18.json b/foundational_analysis/cases/case02/case02_18.json new file mode 100644 index 0000000000000000000000000000000000000000..a0bcabddc2edcb175659b8e6eea9ecf65aa5ca03 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_18.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_03.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 6.319008, + "tolerance": 0.631901 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.504666, + "tolerance": 0.150467 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_19.json b/foundational_analysis/cases/case02/case02_19.json new file mode 100644 index 0000000000000000000000000000000000000000..9c980c0d6b93c8bffbcca1fa617c0fd586e355fa --- /dev/null +++ b/foundational_analysis/cases/case02/case02_19.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_04.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 1.254156, + "tolerance": 0.125416 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 5.571346, + "tolerance": 0.557135 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_20.json b/foundational_analysis/cases/case02/case02_20.json new file mode 100644 index 0000000000000000000000000000000000000000..f1159d5815946aebe4ef29615bdc981785e96e6b --- /dev/null +++ b/foundational_analysis/cases/case02/case02_20.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_05.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 3.528239, + "tolerance": 0.352824 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 2.723892, + "tolerance": 0.272389 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_21.json b/foundational_analysis/cases/case02/case02_21.json new file mode 100644 index 0000000000000000000000000000000000000000..584ba22d7c2db7081388c47331301c38c4d207c1 --- /dev/null +++ b/foundational_analysis/cases/case02/case02_21.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 2.952141, + "tolerance": 0.295214 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.846158, + "tolerance": 0.084616 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_22.json b/foundational_analysis/cases/case02/case02_22.json new file mode 100644 index 0000000000000000000000000000000000000000..f6b4ed5533014556728de4766ea7ed2345e503df --- /dev/null +++ b/foundational_analysis/cases/case02/case02_22.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_02.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 1.128332, + "tolerance": 0.112833 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.040372, + "tolerance": 0.104037 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_23.json b/foundational_analysis/cases/case02/case02_23.json new file mode 100644 index 0000000000000000000000000000000000000000..ea6f2a6dc475c0611b646e789fd52e35dffc5dee --- /dev/null +++ b/foundational_analysis/cases/case02/case02_23.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_03.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 1.035565, + "tolerance": 0.103557 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 0.463546, + "tolerance": 0.046355 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_24.json b/foundational_analysis/cases/case02/case02_24.json new file mode 100644 index 0000000000000000000000000000000000000000..ce140165b44a76a5d484b05517e5f0005fc04c8e --- /dev/null +++ b/foundational_analysis/cases/case02/case02_24.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_04.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 2.892534, + "tolerance": 0.289253 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.24287, + "tolerance": 0.124287 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case02/case02_25.json b/foundational_analysis/cases/case02/case02_25.json new file mode 100644 index 0000000000000000000000000000000000000000..249378b93e6165a2320847af78c89c368f354ffb --- /dev/null +++ b/foundational_analysis/cases/case02/case02_25.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_05.edf", + "instruction": "Please select all available prefrontal EEG channels (FP*/AF* channels) from the raw signal; if the recording has no FP or AF channels, use F3/F4 as frontal proxies. Apply a 1-40Hz FIR bandpass filter and estimate the PSD using the Welch method. Obtain theta [4,8)Hz, alpha [8,13)Hz, and beta [13,30]Hz band power by integrating the PSD over each frequency band. First sum each band power across all selected channels, then calculate ABR = summed alpha power / summed beta power and TBR = summed theta power / summed beta power. Clearly report both final values in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two values from the agent's report:\n1) Alpha/Beta Ratio (ABR)\n2) Theta/Beta Ratio (TBR)\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in the JSON must be EXACTLY \"abr\" and \"tbr\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"abr\": , \"tbr\": }", + "metrics": [ + { + "metric_id": "prefrontal_abr_accuracy", + "type": "numeric_check", + "target_key": "abr", + "weight": 50, + "params": { + "gt_value": 0.996986, + "tolerance": 0.099699 + } + }, + { + "metric_id": "prefrontal_tbr_accuracy", + "type": "numeric_check", + "target_key": "tbr", + "weight": 50, + "params": { + "gt_value": 1.322632, + "tolerance": 0.132263 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_01.json b/foundational_analysis/cases/case03/case03_01.json new file mode 100644 index 0000000000000000000000000000000000000000..48e2793d35b57085cfc846bdcc8eda9262cb1797 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_01.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.706401, + "tolerance": 0.03532 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_02.json b/foundational_analysis/cases/case03/case03_02.json new file mode 100644 index 0000000000000000000000000000000000000000..52a2f7f7f28dfedd135519e1a8f472fc54a4e812 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_02.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_02.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.581186, + "tolerance": 0.029059 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_03.json b/foundational_analysis/cases/case03/case03_03.json new file mode 100644 index 0000000000000000000000000000000000000000..f0fd61dd8bd65e3904b40381246989b8d23aa52a --- /dev/null +++ b/foundational_analysis/cases/case03/case03_03.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_03.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.797815, + "tolerance": 0.039891 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_04.json b/foundational_analysis/cases/case03/case03_04.json new file mode 100644 index 0000000000000000000000000000000000000000..c4b8d7cac835028b1d27533e07ed08e742921f4f --- /dev/null +++ b/foundational_analysis/cases/case03/case03_04.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_04.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.259607, + "tolerance": 0.01298 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_05.json b/foundational_analysis/cases/case03/case03_05.json new file mode 100644 index 0000000000000000000000000000000000000000..885d551217a2052c223bb2535e8bcc0a5e2c5bd8 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_05.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "ISRUC_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_05.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.413254, + "tolerance": 0.020663 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_06.json b/foundational_analysis/cases/case03/case03_06.json new file mode 100644 index 0000000000000000000000000000000000000000..9bf370c77c8c0c67529b16323587e84784e277f1 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_06.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 1.923324, + "tolerance": 0.096168 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_07.json b/foundational_analysis/cases/case03/case03_07.json new file mode 100644 index 0000000000000000000000000000000000000000..dbaba622056d46a5938ce2f370688940c928a991 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_07.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_02.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 1.954942, + "tolerance": 0.097744 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_08.json b/foundational_analysis/cases/case03/case03_08.json new file mode 100644 index 0000000000000000000000000000000000000000..eb22d44083de15cf244feb4b8acbdf4e75a019a0 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_08.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_03.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 2.011129, + "tolerance": 0.100559 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_09.json b/foundational_analysis/cases/case03/case03_09.json new file mode 100644 index 0000000000000000000000000000000000000000..5ea022b784c88224d779a53e0767c76c569226ca --- /dev/null +++ b/foundational_analysis/cases/case03/case03_09.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_04.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 1.673776, + "tolerance": 0.083687 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_10.json b/foundational_analysis/cases/case03/case03_10.json new file mode 100644 index 0000000000000000000000000000000000000000..e738e2c7a53b794718e17ed266d0e0ed4aa6366e --- /dev/null +++ b/foundational_analysis/cases/case03/case03_10.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_05.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 2.1144, + "tolerance": 0.105719 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_11.json b/foundational_analysis/cases/case03/case03_11.json new file mode 100644 index 0000000000000000000000000000000000000000..05263b6689657f17487a8ddfc04ced9e8f3aa14f --- /dev/null +++ b/foundational_analysis/cases/case03/case03_11.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.41036, + "tolerance": 0.020518 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_12.json b/foundational_analysis/cases/case03/case03_12.json new file mode 100644 index 0000000000000000000000000000000000000000..d9ff83e6b1d64de47c0ffff899a90f0a3a854f3f --- /dev/null +++ b/foundational_analysis/cases/case03/case03_12.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-02.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-02.cnt", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.194173, + "tolerance": 0.009709 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_13.json b/foundational_analysis/cases/case03/case03_13.json new file mode 100644 index 0000000000000000000000000000000000000000..0f6cd873438b21292428e991d0ffdf914123644d --- /dev/null +++ b/foundational_analysis/cases/case03/case03_13.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-03.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-03.cnt", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.409418, + "tolerance": 0.020471 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_14.json b/foundational_analysis/cases/case03/case03_14.json new file mode 100644 index 0000000000000000000000000000000000000000..670c39b54e0aafce6b42d96e1fcc8071c8062c85 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_14.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-04.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-04.cnt", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.559666, + "tolerance": 0.027983 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_15.json b/foundational_analysis/cases/case03/case03_15.json new file mode 100644 index 0000000000000000000000000000000000000000..c2d49fa5d28649a4b983523e25eb98727d4513d6 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_15.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "SEED-V-05.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-05.cnt", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.225895, + "tolerance": 0.011295 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_16.json b/foundational_analysis/cases/case03/case03_16.json new file mode 100644 index 0000000000000000000000000000000000000000..2cd847688fc777c2dd4f1c51f674735081b4d344 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_16.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.956782, + "tolerance": 0.047839 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_17.json b/foundational_analysis/cases/case03/case03_17.json new file mode 100644 index 0000000000000000000000000000000000000000..c5f9871fdd8466c138785d7ebd6899d109313e3b --- /dev/null +++ b/foundational_analysis/cases/case03/case03_17.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_02.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.396196, + "tolerance": 0.01981 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_18.json b/foundational_analysis/cases/case03/case03_18.json new file mode 100644 index 0000000000000000000000000000000000000000..4756ac1e1376cb2bcae6a8b01affe4a0e5a1b59a --- /dev/null +++ b/foundational_analysis/cases/case03/case03_18.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_03.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.652412, + "tolerance": 0.032621 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_19.json b/foundational_analysis/cases/case03/case03_19.json new file mode 100644 index 0000000000000000000000000000000000000000..11bd3f7b88a6d9bb3e321b80fdf6fb62211576fd --- /dev/null +++ b/foundational_analysis/cases/case03/case03_19.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_04.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.949021, + "tolerance": 0.047451 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_20.json b/foundational_analysis/cases/case03/case03_20.json new file mode 100644 index 0000000000000000000000000000000000000000..90b3c330cf118a7ad976eff86007f195273d4afe --- /dev/null +++ b/foundational_analysis/cases/case03/case03_20.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_05.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 1.275055, + "tolerance": 0.063753 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_21.json b/foundational_analysis/cases/case03/case03_21.json new file mode 100644 index 0000000000000000000000000000000000000000..5bb7c20b603e8afdf2079d693adfd3129f0113ce --- /dev/null +++ b/foundational_analysis/cases/case03/case03_21.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.43688, + "tolerance": 0.021844 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_22.json b/foundational_analysis/cases/case03/case03_22.json new file mode 100644 index 0000000000000000000000000000000000000000..cf3836b5e11599a0c1de2cbb4641b0ac1fd43f48 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_22.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_02.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.47464, + "tolerance": 0.023732 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_23.json b/foundational_analysis/cases/case03/case03_23.json new file mode 100644 index 0000000000000000000000000000000000000000..300be7ed11c90e8e685e19048ac189201a0fa3ab --- /dev/null +++ b/foundational_analysis/cases/case03/case03_23.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_03.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.49237, + "tolerance": 0.024619 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_24.json b/foundational_analysis/cases/case03/case03_24.json new file mode 100644 index 0000000000000000000000000000000000000000..878f846839a7419ce96f32949de23fe19c4fbfe0 --- /dev/null +++ b/foundational_analysis/cases/case03/case03_24.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_04.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.416207, + "tolerance": 0.02081 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case03/case03_25.json b/foundational_analysis/cases/case03/case03_25.json new file mode 100644 index 0000000000000000000000000000000000000000..62221d739d7c853a7d5e443b64a13cbb959f44ba --- /dev/null +++ b/foundational_analysis/cases/case03/case03_25.json @@ -0,0 +1,27 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_05.edf", + "instruction": "Please select only the occipital EEG channels from the raw signal first. For each selected channel, use only the first 30 seconds of signal and compute Sample Entropy (SampEn) with m=2 and r=0.2 times the standard deviation of that channel segment. Then calculate the average SampEn across all selected channels and report the final mean value clearly." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final 'Mean Sample Entropy' value from the agent report.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The key in JSON must be EXACTLY \"sampen_mean\".\n5. The value must be a FLOAT.\n6. If missing or unrecognized, return {\"sampen_mean\": null}.\n\n### OUTPUT TEMPLATE\n{\"sampen_mean\": }", + "metrics": [ + { + "metric_id": "sampen_mean_accuracy", + "type": "numeric_check", + "target_key": "sampen_mean", + "weight": 100, + "params": { + "gt_value": 0.394084, + "tolerance": 0.019704 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case04/case04_01.json b/foundational_analysis/cases/case04/case04_01.json new file mode 100644 index 0000000000000000000000000000000000000000..fac48c3f212f737bf6bb4d61812e2d32eb2cea59 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_01.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.586117, + "tolerance": 0.029306 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.26804, + "tolerance": 0.113402 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_02.json b/foundational_analysis/cases/case04/case04_02.json new file mode 100644 index 0000000000000000000000000000000000000000..5d6f04bab97a809e47d37976a034eca6f3e47969 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_02.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_02.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 1.005496, + "tolerance": 0.050275 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.452115, + "tolerance": 0.072606 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_03.json b/foundational_analysis/cases/case04/case04_03.json new file mode 100644 index 0000000000000000000000000000000000000000..19b22243096106d7466d5f6468d830d61ec17105 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_03.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_03.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.716345, + "tolerance": 0.035817 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.65056, + "tolerance": 0.082528 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_04.json b/foundational_analysis/cases/case04/case04_04.json new file mode 100644 index 0000000000000000000000000000000000000000..e371f5b1d6a74caa932c5402e2c4a142bf24495d --- /dev/null +++ b/foundational_analysis/cases/case04/case04_04.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_04.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.753642, + "tolerance": 0.037682 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.961207, + "tolerance": 0.09806 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_05.json b/foundational_analysis/cases/case04/case04_05.json new file mode 100644 index 0000000000000000000000000000000000000000..efe2edb8862c690920d4442ff84346ab0d29d7f1 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_05.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_05.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.852665, + "tolerance": 0.042633 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.723293, + "tolerance": 0.086165 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_06.json b/foundational_analysis/cases/case04/case04_06.json new file mode 100644 index 0000000000000000000000000000000000000000..007dfe17a0f8f84c1aaa27db74b9bc782fb9a465 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_06.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 1.400182, + "tolerance": 0.070009 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.223736, + "tolerance": 0.061187 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_07.json b/foundational_analysis/cases/case04/case04_07.json new file mode 100644 index 0000000000000000000000000000000000000000..2c575d87b4c9f9a01705b27e83508ba21ed7a74f --- /dev/null +++ b/foundational_analysis/cases/case04/case04_07.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_02.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 1.393716, + "tolerance": 0.069686 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.21654, + "tolerance": 0.060827 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_08.json b/foundational_analysis/cases/case04/case04_08.json new file mode 100644 index 0000000000000000000000000000000000000000..b1b1a3953838e162a8afc31fdd0a1db4c61444df --- /dev/null +++ b/foundational_analysis/cases/case04/case04_08.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_03.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 1.343013, + "tolerance": 0.067151 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.264461, + "tolerance": 0.063223 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_09.json b/foundational_analysis/cases/case04/case04_09.json new file mode 100644 index 0000000000000000000000000000000000000000..da0311f304886a593420048a088534b2a4809a0e --- /dev/null +++ b/foundational_analysis/cases/case04/case04_09.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_04.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 1.377489, + "tolerance": 0.068874 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.248801, + "tolerance": 0.06244 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_10.json b/foundational_analysis/cases/case04/case04_10.json new file mode 100644 index 0000000000000000000000000000000000000000..4d48636c1036c759bb41e3bf9fccd9271d145bd7 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_10.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_05.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 1.374781, + "tolerance": 0.068739 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.243467, + "tolerance": 0.062173 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_11.json b/foundational_analysis/cases/case04/case04_11.json new file mode 100644 index 0000000000000000000000000000000000000000..10355ae9ddb4a3d1e43e7ec66b3cca562d0343cb --- /dev/null +++ b/foundational_analysis/cases/case04/case04_11.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.69919, + "tolerance": 0.034959 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.390286, + "tolerance": 0.119514 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_12.json b/foundational_analysis/cases/case04/case04_12.json new file mode 100644 index 0000000000000000000000000000000000000000..9b9b4a6e4ebf60a1f4d741d1de31f48cb61d5f21 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_12.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-02.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-02.cnt", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.637071, + "tolerance": 0.031854 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.338962, + "tolerance": 0.116948 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_13.json b/foundational_analysis/cases/case04/case04_13.json new file mode 100644 index 0000000000000000000000000000000000000000..f045169411ed12e544ac06c5ef934a07ccd5d5f2 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_13.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-03.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-03.cnt", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.683709, + "tolerance": 0.034185 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.266517, + "tolerance": 0.113326 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_14.json b/foundational_analysis/cases/case04/case04_14.json new file mode 100644 index 0000000000000000000000000000000000000000..4fda1e17b24f7e82c9b2deb753d5fb4df3675049 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_14.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-04.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-04.cnt", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.648689, + "tolerance": 0.032434 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.144298, + "tolerance": 0.107215 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_15.json b/foundational_analysis/cases/case04/case04_15.json new file mode 100644 index 0000000000000000000000000000000000000000..3eb3dcc6f54fa48b96e1a2c2a12047020ae95801 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_15.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-05.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-05.cnt", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.491138, + "tolerance": 0.024557 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.642507, + "tolerance": 0.132125 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_16.json b/foundational_analysis/cases/case04/case04_16.json new file mode 100644 index 0000000000000000000000000000000000000000..c76f32a1f612cfccb8dd04701732d634983b4321 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_16.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.765497, + "tolerance": 0.038275 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.706374, + "tolerance": 0.085319 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_17.json b/foundational_analysis/cases/case04/case04_17.json new file mode 100644 index 0000000000000000000000000000000000000000..c968c1a5677edcf86d718ab6de8292b57974296a --- /dev/null +++ b/foundational_analysis/cases/case04/case04_17.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_02.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.337763, + "tolerance": 0.016888 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 3.750052, + "tolerance": 0.187503 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_18.json b/foundational_analysis/cases/case04/case04_18.json new file mode 100644 index 0000000000000000000000000000000000000000..5b114efe85a4a01ee260383eb99f14cd4434d5ce --- /dev/null +++ b/foundational_analysis/cases/case04/case04_18.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_03.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.71508, + "tolerance": 0.035754 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.525094, + "tolerance": 0.076255 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_19.json b/foundational_analysis/cases/case04/case04_19.json new file mode 100644 index 0000000000000000000000000000000000000000..9e607886372edce8a04f7384e57ce1236fc5b2dc --- /dev/null +++ b/foundational_analysis/cases/case04/case04_19.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_04.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.530136, + "tolerance": 0.026507 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.620176, + "tolerance": 0.131009 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_20.json b/foundational_analysis/cases/case04/case04_20.json new file mode 100644 index 0000000000000000000000000000000000000000..b9b2ff6a823d3fa2b3da087b474e64dea7589dda --- /dev/null +++ b/foundational_analysis/cases/case04/case04_20.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_05.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.9439, + "tolerance": 0.047195 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.745986, + "tolerance": 0.087299 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_21.json b/foundational_analysis/cases/case04/case04_21.json new file mode 100644 index 0000000000000000000000000000000000000000..27f7550f072d93d27325a5d575d98d69174a1e5c --- /dev/null +++ b/foundational_analysis/cases/case04/case04_21.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.53272, + "tolerance": 0.026636 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.117709, + "tolerance": 0.105885 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_22.json b/foundational_analysis/cases/case04/case04_22.json new file mode 100644 index 0000000000000000000000000000000000000000..bddfe0e09719febaca500f21a6ca1f17295f1d23 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_22.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_02.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.591011, + "tolerance": 0.029551 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.248344, + "tolerance": 0.112417 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_23.json b/foundational_analysis/cases/case04/case04_23.json new file mode 100644 index 0000000000000000000000000000000000000000..21964ca5155c214c7f1b7a3ae0b62706c0a63c21 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_23.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_03.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.578241, + "tolerance": 0.028912 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.118097, + "tolerance": 0.105905 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_24.json b/foundational_analysis/cases/case04/case04_24.json new file mode 100644 index 0000000000000000000000000000000000000000..0c9a35650c6d4b0db79f486250c36ae306645409 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_24.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_04.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.49839, + "tolerance": 0.02492 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 1.781463, + "tolerance": 0.089073 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case04/case04_25.json b/foundational_analysis/cases/case04/case04_25.json new file mode 100644 index 0000000000000000000000000000000000000000..b40693f0ab2cdfa893956cafebc5ec21310e6233 --- /dev/null +++ b/foundational_analysis/cases/case04/case04_25.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_05.edf", + "instruction": "Please select only the central-region EEG channels (C* and CP*). Apply a 50 Hz FIR notch filter, then a 0.5-45 Hz FIR bandpass filter, resample to 100 Hz, and re-reference using average reference. Use the first 90 seconds of each selected channel. Compute Hjorth Mobility and Hjorth Complexity for each channel, then report the channel-mean values as hjorth_mobility_mean and hjorth_complexity_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean Hjorth Mobility\n2) Mean Hjorth Complexity\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"hjorth_mobility_mean\" and \"hjorth_complexity_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"hjorth_mobility_mean\": , \"hjorth_complexity_mean\": }", + "metrics": [ + { + "metric_id": "hjorth_mobility_accuracy", + "type": "numeric_check", + "target_key": "hjorth_mobility_mean", + "weight": 50, + "params": { + "gt_value": 0.5692, + "tolerance": 0.02846 + } + }, + { + "metric_id": "hjorth_complexity_accuracy", + "type": "numeric_check", + "target_key": "hjorth_complexity_mean", + "weight": 50, + "params": { + "gt_value": 2.190244, + "tolerance": 0.109512 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_01.json b/foundational_analysis/cases/case05/case05_01.json new file mode 100644 index 0000000000000000000000000000000000000000..15c0676a1c218afc02055843048c0cb8cf581fc0 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_01.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please select only the central (C*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_c_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of central channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_c_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_c_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_c_accuracy", + "type": "numeric_check", + "target_key": "sef95_c_mean", + "weight": 50, + "params": { + "gt_value": 20.875, + "tolerance": 1.04375 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 14.0, + "tolerance": 0.7 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_02.json b/foundational_analysis/cases/case05/case05_02.json new file mode 100644 index 0000000000000000000000000000000000000000..f6c2618fe93f7e6e2f9b898a3c889bc0075cc683 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_02.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_02.edf", + "instruction": "Please select only the central (C*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_c_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of central channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_c_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_c_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_c_accuracy", + "type": "numeric_check", + "target_key": "sef95_c_mean", + "weight": 50, + "params": { + "gt_value": 18.25, + "tolerance": 0.9125 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 16.125, + "tolerance": 0.80625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_03.json b/foundational_analysis/cases/case05/case05_03.json new file mode 100644 index 0000000000000000000000000000000000000000..3e1c3055685047df033660a2ee1fddd0b42427ac --- /dev/null +++ b/foundational_analysis/cases/case05/case05_03.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_03.edf", + "instruction": "Please select only the central (C*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_c_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of central channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_c_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_c_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_c_accuracy", + "type": "numeric_check", + "target_key": "sef95_c_mean", + "weight": 50, + "params": { + "gt_value": 18.625, + "tolerance": 0.93125 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 17.375, + "tolerance": 0.86875 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_04.json b/foundational_analysis/cases/case05/case05_04.json new file mode 100644 index 0000000000000000000000000000000000000000..460dae66842029b4b3b3d3a9734f0db6bae241d3 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_04.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_04.edf", + "instruction": "Please select only the central (C*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_c_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of central channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_c_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_c_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_c_accuracy", + "type": "numeric_check", + "target_key": "sef95_c_mean", + "weight": 50, + "params": { + "gt_value": 13.75, + "tolerance": 0.6875 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 17.25, + "tolerance": 0.8625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_05.json b/foundational_analysis/cases/case05/case05_05.json new file mode 100644 index 0000000000000000000000000000000000000000..e61c7509e5af8b2ca3c48dbe9257566f77154237 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_05.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "ISRUC_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_05.edf", + "instruction": "Please select only the central (C*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_c_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of central channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_c_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_c_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_c_accuracy", + "type": "numeric_check", + "target_key": "sef95_c_mean", + "weight": 50, + "params": { + "gt_value": 21.5, + "tolerance": 1.075 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 25.25, + "tolerance": 1.2625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_06.json b/foundational_analysis/cases/case05/case05_06.json new file mode 100644 index 0000000000000000000000000000000000000000..9415ea25184ec9b16e9e0430d81d43fa7def007b --- /dev/null +++ b/foundational_analysis/cases/case05/case05_06.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 37.833333, + "tolerance": 1.891667 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 38.75, + "tolerance": 1.9375 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_07.json b/foundational_analysis/cases/case05/case05_07.json new file mode 100644 index 0000000000000000000000000000000000000000..a2a72d51e1b68ae1ffdd39d2718cdee77893ae91 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_07.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_02.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 37.972222, + "tolerance": 1.898611 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 37.833333, + "tolerance": 1.891667 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_08.json b/foundational_analysis/cases/case05/case05_08.json new file mode 100644 index 0000000000000000000000000000000000000000..f963459010e43ae2e660be839c6746b2e6512e37 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_08.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_03.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 37.0, + "tolerance": 1.85 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 37.5, + "tolerance": 1.875 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_09.json b/foundational_analysis/cases/case05/case05_09.json new file mode 100644 index 0000000000000000000000000000000000000000..3b0503288a7e2a5ac1262449d95d986a5c9df034 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_09.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_04.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 37.583333, + "tolerance": 1.879167 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 38.083333, + "tolerance": 1.904167 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_10.json b/foundational_analysis/cases/case05/case05_10.json new file mode 100644 index 0000000000000000000000000000000000000000..ac1f836205f1a8fd5872ac27bd05f653701c8816 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_10.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_05.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 37.638889, + "tolerance": 1.881944 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 37.75, + "tolerance": 1.8875 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_11.json b/foundational_analysis/cases/case05/case05_11.json new file mode 100644 index 0000000000000000000000000000000000000000..65a82fd95fe1fa6adcd81d9dc93cb589cb79c949 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_11.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 26.527778, + "tolerance": 1.326389 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 30.916667, + "tolerance": 1.545833 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_12.json b/foundational_analysis/cases/case05/case05_12.json new file mode 100644 index 0000000000000000000000000000000000000000..600e2509da00b0c7a796b8227b1c27cc104c01ff --- /dev/null +++ b/foundational_analysis/cases/case05/case05_12.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-02.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-02.cnt", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 19.277778, + "tolerance": 0.963889 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 19.333333, + "tolerance": 0.966667 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_13.json b/foundational_analysis/cases/case05/case05_13.json new file mode 100644 index 0000000000000000000000000000000000000000..6ff8830f0dd00bf4f890859043e08d3cd91a264d --- /dev/null +++ b/foundational_analysis/cases/case05/case05_13.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-03.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-03.cnt", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 26.277778, + "tolerance": 1.313889 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 32.5, + "tolerance": 1.625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_14.json b/foundational_analysis/cases/case05/case05_14.json new file mode 100644 index 0000000000000000000000000000000000000000..4474259a868d72faecfddec4ad5f368e2b9ed244 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_14.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-04.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-04.cnt", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 27.416667, + "tolerance": 1.370833 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 30.416667, + "tolerance": 1.520833 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_15.json b/foundational_analysis/cases/case05/case05_15.json new file mode 100644 index 0000000000000000000000000000000000000000..bfed5c81c1c6aca81248f6591b84775a36424870 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_15.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "SEED-V-05.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-05.cnt", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 17.555556, + "tolerance": 0.877778 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 19.583333, + "tolerance": 0.979167 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_16.json b/foundational_analysis/cases/case05/case05_16.json new file mode 100644 index 0000000000000000000000000000000000000000..9b954ee7eb4e498ad932bf490a8427e32ec1eeb1 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_16.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 23.166667, + "tolerance": 1.158333 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 27.25, + "tolerance": 1.3625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_17.json b/foundational_analysis/cases/case05/case05_17.json new file mode 100644 index 0000000000000000000000000000000000000000..3521923da17039a1454481ff83c86a099e12393e --- /dev/null +++ b/foundational_analysis/cases/case05/case05_17.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_02.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 17.416667, + "tolerance": 0.870833 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 19.125, + "tolerance": 0.95625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_18.json b/foundational_analysis/cases/case05/case05_18.json new file mode 100644 index 0000000000000000000000000000000000000000..27e5623e09b1ae1fdf753b81e808c57ac6f07d47 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_18.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_03.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 18.583333, + "tolerance": 0.929167 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 18.375, + "tolerance": 0.91875 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_19.json b/foundational_analysis/cases/case05/case05_19.json new file mode 100644 index 0000000000000000000000000000000000000000..9c94597775262d67f02ab03422df1bfebf95f32f --- /dev/null +++ b/foundational_analysis/cases/case05/case05_19.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_04.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 23.0, + "tolerance": 1.15 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 24.25, + "tolerance": 1.2125 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_20.json b/foundational_analysis/cases/case05/case05_20.json new file mode 100644 index 0000000000000000000000000000000000000000..e04f8c2d0c728911d5a043dbf3d9f2549341af8e --- /dev/null +++ b/foundational_analysis/cases/case05/case05_20.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_05.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 18.166667, + "tolerance": 0.908333 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 17.25, + "tolerance": 0.8625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_21.json b/foundational_analysis/cases/case05/case05_21.json new file mode 100644 index 0000000000000000000000000000000000000000..6d063366f20ad6989c0794948b273524032f832a --- /dev/null +++ b/foundational_analysis/cases/case05/case05_21.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 21.916667, + "tolerance": 1.095833 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 21.125, + "tolerance": 1.05625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_22.json b/foundational_analysis/cases/case05/case05_22.json new file mode 100644 index 0000000000000000000000000000000000000000..045cf97c73d2af307ecc9acd7023a1cd04333e82 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_22.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_02.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 19.0, + "tolerance": 0.95 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 18.75, + "tolerance": 0.9375 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_23.json b/foundational_analysis/cases/case05/case05_23.json new file mode 100644 index 0000000000000000000000000000000000000000..b6cdadb4fadf77ebb9b9fd9e6b834516b03a7885 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_23.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_03.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 18.333333, + "tolerance": 0.916667 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 19.625, + "tolerance": 0.98125 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_24.json b/foundational_analysis/cases/case05/case05_24.json new file mode 100644 index 0000000000000000000000000000000000000000..db9538d8bc5749ba4bd9e60840526c53a52ca803 --- /dev/null +++ b/foundational_analysis/cases/case05/case05_24.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_04.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 17.5, + "tolerance": 0.875 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 17.875, + "tolerance": 0.89375 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case05/case05_25.json b/foundational_analysis/cases/case05/case05_25.json new file mode 100644 index 0000000000000000000000000000000000000000..858f6957b74f6cc37e59b45cba3fb7d092662c8a --- /dev/null +++ b/foundational_analysis/cases/case05/case05_25.json @@ -0,0 +1,37 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_05.edf", + "instruction": "Please select only the parietal (P*) and occipital (O*) EEG channels from the raw signal. Apply a 0.5-40 Hz FIR bandpass filter, then a 60 Hz FIR notch filter, and resample to 200 Hz. Compute the SEF95 value for each selected channel over the full available signal, then report the region-mean values as sef95_p_mean and sef95_o_mean." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final values from the agent report:\n1) Mean SEF95 of parietal channels\n2) Mean SEF95 of occipital channels\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"sef95_p_mean\" and \"sef95_o_mean\".\n5. Both values must be FLOAT.\n6. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"sef95_p_mean\": , \"sef95_o_mean\": }", + "metrics": [ + { + "metric_id": "sef95_p_accuracy", + "type": "numeric_check", + "target_key": "sef95_p_mean", + "weight": 50, + "params": { + "gt_value": 18.25, + "tolerance": 0.9125 + } + }, + { + "metric_id": "sef95_o_accuracy", + "type": "numeric_check", + "target_key": "sef95_o_mean", + "weight": 50, + "params": { + "gt_value": 17.125, + "tolerance": 0.85625 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case06/case06_01.json b/foundational_analysis/cases/case06/case06_01.json new file mode 100644 index 0000000000000000000000000000000000000000..9a3143caeafcd0ee7fc729a7f0cbc2095c60e89e --- /dev/null +++ b/foundational_analysis/cases/case06/case06_01.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "MEDIUM" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.134972, + "tolerance": 0.013497 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_02.json b/foundational_analysis/cases/case06/case06_02.json new file mode 100644 index 0000000000000000000000000000000000000000..7813ced041018c7cb8d976e6a753ef2939c769e6 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_02.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "ISRUC_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_02.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "MEDIUM" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.199948, + "tolerance": 0.019995 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_03.json b/foundational_analysis/cases/case06/case06_03.json new file mode 100644 index 0000000000000000000000000000000000000000..7f84ce7cd83e485955b9e401f4114b2debd6070c --- /dev/null +++ b/foundational_analysis/cases/case06/case06_03.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "ISRUC_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_03.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "MEDIUM" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.118846, + "tolerance": 0.011885 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_04.json b/foundational_analysis/cases/case06/case06_04.json new file mode 100644 index 0000000000000000000000000000000000000000..ec53e2debfa84622c22f2bad76b86adcb2e9ce14 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_04.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "ISRUC_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_04.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "MEDIUM" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.156256, + "tolerance": 0.015626 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_05.json b/foundational_analysis/cases/case06/case06_05.json new file mode 100644 index 0000000000000000000000000000000000000000..be321ddb3bc832d2636c925db36ce2a1bdf6b151 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_05.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "ISRUC_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_05.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "MEDIUM" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.171527, + "tolerance": 0.017153 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_06.json b/foundational_analysis/cases/case06/case06_06.json new file mode 100644 index 0000000000000000000000000000000000000000..dc9ae946a40268c462b1194bf12be60004789e24 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_06.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.000668, + "tolerance": 6.7e-05 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_07.json b/foundational_analysis/cases/case06/case06_07.json new file mode 100644 index 0000000000000000000000000000000000000000..8f2d8634f0385d8dced06cf12d51593644a50475 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_07.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_02.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.000156, + "tolerance": 1.6e-05 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_08.json b/foundational_analysis/cases/case06/case06_08.json new file mode 100644 index 0000000000000000000000000000000000000000..f9e9b9c54f805d4a44c7b082c48f55bc250e4c6d --- /dev/null +++ b/foundational_analysis/cases/case06/case06_08.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_03.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.000908, + "tolerance": 9.1e-05 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_09.json b/foundational_analysis/cases/case06/case06_09.json new file mode 100644 index 0000000000000000000000000000000000000000..78afe38a548696dc64f11c2663798957c5162a2c --- /dev/null +++ b/foundational_analysis/cases/case06/case06_09.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_04.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.000111, + "tolerance": 1.1e-05 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_10.json b/foundational_analysis/cases/case06/case06_10.json new file mode 100644 index 0000000000000000000000000000000000000000..b4c1266d83e13ff25ee69d9723b1906b519f58e4 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_10.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_05.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.000463, + "tolerance": 4.6e-05 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_11.json b/foundational_analysis/cases/case06/case06_11.json new file mode 100644 index 0000000000000000000000000000000000000000..a8fe02a0df82d73cebc95fa00c8a929641a91f5f --- /dev/null +++ b/foundational_analysis/cases/case06/case06_11.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.032954, + "tolerance": 0.003295 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_12.json b/foundational_analysis/cases/case06/case06_12.json new file mode 100644 index 0000000000000000000000000000000000000000..cf5a8a193596f9317c1a0e0a1543a809504f2bdd --- /dev/null +++ b/foundational_analysis/cases/case06/case06_12.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_02.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.046012, + "tolerance": 0.004601 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_13.json b/foundational_analysis/cases/case06/case06_13.json new file mode 100644 index 0000000000000000000000000000000000000000..eebbb10abf471debd25c80136ed79dfd2d96610a --- /dev/null +++ b/foundational_analysis/cases/case06/case06_13.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_03.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.004734, + "tolerance": 0.000473 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_14.json b/foundational_analysis/cases/case06/case06_14.json new file mode 100644 index 0000000000000000000000000000000000000000..c74e0f1ffaa88d41dde7d5b69186f2fe6cfb0501 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_14.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_04.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.003685, + "tolerance": 0.000369 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_15.json b/foundational_analysis/cases/case06/case06_15.json new file mode 100644 index 0000000000000000000000000000000000000000..579660167191ac4794434a8a396c3e4e3e1b3b74 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_15.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_05.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.011306, + "tolerance": 0.001131 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_16.json b/foundational_analysis/cases/case06/case06_16.json new file mode 100644 index 0000000000000000000000000000000000000000..6254540caa2b7c09018f755c1a6534e6a2574b19 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_16.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.010642, + "tolerance": 0.001064 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_17.json b/foundational_analysis/cases/case06/case06_17.json new file mode 100644 index 0000000000000000000000000000000000000000..2c01b1955f992989ba3cc77007dc0be8bcbf7fca --- /dev/null +++ b/foundational_analysis/cases/case06/case06_17.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_02.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.054164, + "tolerance": 0.005416 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_18.json b/foundational_analysis/cases/case06/case06_18.json new file mode 100644 index 0000000000000000000000000000000000000000..f52d45bec11f83792345b025aad53962d3688459 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_18.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_03.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.047591, + "tolerance": 0.004759 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_19.json b/foundational_analysis/cases/case06/case06_19.json new file mode 100644 index 0000000000000000000000000000000000000000..4018ba1d5234b4fc80b52f5c5e0450da876036b1 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_19.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_04.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.013472, + "tolerance": 0.001347 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case06/case06_20.json b/foundational_analysis/cases/case06/case06_20.json new file mode 100644 index 0000000000000000000000000000000000000000..371c500e9313c26f066a196dd3d8009f10fa6611 --- /dev/null +++ b/foundational_analysis/cases/case06/case06_20.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_05.edf", + "instruction": "Please select only the real EEG channels from the raw signal (excluding non-EEG channels). Do not apply linear detrending. For each selected channel, obtain the power in the 0.1-0.5 Hz band and the total power in the 0.1-45 Hz band by integrating the PSD over frequency, then calculate the channel-wise baseline-drift power ratio. Average these channel-wise ratios to obtain the final ratio. Classify the baseline drift level as LOW, MEDIUM, or HIGH using these thresholds: LOW if ratio < 0.08, MEDIUM if 0.08 <= ratio < 0.25, and HIGH if ratio >= 0.25. Report both the final ratio value and the final level in your response." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two final outputs from the agent report:\n1) Baseline-drift power ratio (0.1-0.5 Hz / 0.1-45 Hz)\n2) Baseline-drift level\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks (e.g., no backticks or json tags).\n3. DO NOT include any conversational text, explanations, or units.\n4. The keys in JSON must be EXACTLY \"drift_ratio\" and \"drift_level\".\n5. \"drift_ratio\" must be a FLOAT.\n6. \"drift_level\" must be one of \"LOW\", \"MEDIUM\", \"HIGH\".\n7. If one value is missing, return it as null.\n\n### OUTPUT TEMPLATE\n{\"drift_ratio\": , \"drift_level\": }", + "metrics": [ + { + "metric_id": "baseline_drift_level_accuracy", + "type": "categorical_check", + "target_key": "drift_level", + "weight": 100, + "params": { + "gt_value": "LOW" + } + }, + { + "metric_id": "baseline_drift_ratio_reference", + "type": "numeric_check", + "target_key": "drift_ratio", + "weight": 0, + "params": { + "gt_value": 0.055766, + "tolerance": 0.005577 + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case07/case07_01.json b/foundational_analysis/cases/case07/case07_01.json new file mode 100644 index 0000000000000000000000000000000000000000..874caa4b177c74ebe784bac5fd0f1bca17997c42 --- /dev/null +++ b/foundational_analysis/cases/case07/case07_01.json @@ -0,0 +1,50 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please determine which lead-distribution system this recording follows (10-20, 10-10 or 10-5), and then list all channels that do not belong to standard measurement electrodes of that system. Return the non-standard channels using their original channel names exactly as they appear in the data. If all channels belong to standard measurement electrodes, return an empty list." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two outputs from the agent report:\n1) lead system classification\n2) final list of channels that are not standard measurement electrodes of that system\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The keys in JSON must be EXACTLY \"lead_system\" and \"non_standard_channels\".\n5. \"lead_system\" must be exactly one of \"10-20\", \"10-10\", \"10-5\", or null.\n6. Extract the explicitly reported final non-standard-channel list, not the full channel inventory or the standard-channel list.\n7. Normalize each returned display name only to the benchmark naming contract: trim whitespace and remove one leading acquisition prefix EEG followed by a space, hyphen, or underscore.\n8. If a modality prefix is immediately duplicated, collapse it to one label; for example, \"ECG ECG\" becomes \"ECG\". Preserve the remaining spelling, case, punctuation, and reference identity exactly.\n9. Do NOT remove terminal reference parts and do NOT convert legacy aliases for this case. Required examples: \"EEG A2-A1\" -> \"A2-A1\"; \"EEG 23A-23R\" -> \"23A-23R\"; \"ECG ECG\" -> \"ECG\"; \"SaO2\" -> \"SaO2\".\n10. If the report explicitly says no non-standard channel exists, return an empty array []. If the final list is missing or unclear, set non_standard_channels to null.\n11. If lead_system is missing or unclear, set only lead_system to null; do not guess either value.\n\n### OUTPUT TEMPLATE\n{\"lead_system\": <\"10-20\"|\"10-10\"|\"10-5\"|null>, \"non_standard_channels\": }", + "metrics": [ + { + "metric_id": "lead_system_accuracy", + "type": "categorical_check", + "target_key": "lead_system", + "weight": 50, + "params": { + "gt_value": "10-20" + } + }, + { + "metric_id": "non_standard_channels_match", + "type": "set_match_check", + "target_key": "non_standard_channels", + "weight": 50, + "params": { + "gt_value": [ + "LOC-A2", + "ROC-A1", + "X1", + "X2", + "X3", + "X4", + "X5", + "X6", + "DC3", + "X7", + "X8", + "SaO2", + "DC8" + ], + "match_mode": "exact" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case07/case07_02.json b/foundational_analysis/cases/case07/case07_02.json new file mode 100644 index 0000000000000000000000000000000000000000..e43b52b1f092871ebc15492603daa4bcf2bd125f --- /dev/null +++ b/foundational_analysis/cases/case07/case07_02.json @@ -0,0 +1,36 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please determine which lead-distribution system this recording follows (10-20, 10-10 or 10-5), and then list all channels that do not belong to standard measurement electrodes of that system. Return the non-standard channels using their original channel names exactly as they appear in the data. If all channels belong to standard measurement electrodes, return an empty list." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two outputs from the agent report:\n1) lead system classification\n2) final list of channels that are not standard measurement electrodes of that system\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The keys in JSON must be EXACTLY \"lead_system\" and \"non_standard_channels\".\n5. \"lead_system\" must be exactly one of \"10-20\", \"10-10\", \"10-5\", or null.\n6. Extract the explicitly reported final non-standard-channel list, not the full channel inventory or the standard-channel list.\n7. Normalize each returned display name only to the benchmark naming contract: trim whitespace and remove one leading acquisition prefix EEG followed by a space, hyphen, or underscore.\n8. If a modality prefix is immediately duplicated, collapse it to one label; for example, \"ECG ECG\" becomes \"ECG\". Preserve the remaining spelling, case, punctuation, and reference identity exactly.\n9. Do NOT remove terminal reference parts and do NOT convert legacy aliases for this case. Required examples: \"EEG A2-A1\" -> \"A2-A1\"; \"EEG 23A-23R\" -> \"23A-23R\"; \"ECG ECG\" -> \"ECG\"; \"SaO2\" -> \"SaO2\".\n10. If the report explicitly says no non-standard channel exists, return an empty array []. If the final list is missing or unclear, set non_standard_channels to null.\n11. If lead_system is missing or unclear, set only lead_system to null; do not guess either value.\n\n### OUTPUT TEMPLATE\n{\"lead_system\": <\"10-20\"|\"10-10\"|\"10-5\"|null>, \"non_standard_channels\": }", + "metrics": [ + { + "metric_id": "lead_system_accuracy", + "type": "categorical_check", + "target_key": "lead_system", + "weight": 50, + "params": { + "gt_value": "10-10" + } + }, + { + "metric_id": "non_standard_channels_match", + "type": "set_match_check", + "target_key": "non_standard_channels", + "weight": 50, + "params": { + "gt_value": [], + "match_mode": "exact" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case07/case07_03.json b/foundational_analysis/cases/case07/case07_03.json new file mode 100644 index 0000000000000000000000000000000000000000..4a9024ea28b51321b2005e1d68c3a484187b3066 --- /dev/null +++ b/foundational_analysis/cases/case07/case07_03.json @@ -0,0 +1,43 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please determine which lead-distribution system this recording follows (10-20, 10-10 or 10-5), and then list all channels that do not belong to standard measurement electrodes of that system. Return the non-standard channels using their original channel names exactly as they appear in the data. If all channels belong to standard measurement electrodes, return an empty list." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two outputs from the agent report:\n1) lead system classification\n2) final list of channels that are not standard measurement electrodes of that system\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The keys in JSON must be EXACTLY \"lead_system\" and \"non_standard_channels\".\n5. \"lead_system\" must be exactly one of \"10-20\", \"10-10\", \"10-5\", or null.\n6. Extract the explicitly reported final non-standard-channel list, not the full channel inventory or the standard-channel list.\n7. Normalize each returned display name only to the benchmark naming contract: trim whitespace and remove one leading acquisition prefix EEG followed by a space, hyphen, or underscore.\n8. If a modality prefix is immediately duplicated, collapse it to one label; for example, \"ECG ECG\" becomes \"ECG\". Preserve the remaining spelling, case, punctuation, and reference identity exactly.\n9. Do NOT remove terminal reference parts and do NOT convert legacy aliases for this case. Required examples: \"EEG A2-A1\" -> \"A2-A1\"; \"EEG 23A-23R\" -> \"23A-23R\"; \"ECG ECG\" -> \"ECG\"; \"SaO2\" -> \"SaO2\".\n10. If the report explicitly says no non-standard channel exists, return an empty array []. If the final list is missing or unclear, set non_standard_channels to null.\n11. If lead_system is missing or unclear, set only lead_system to null; do not guess either value.\n\n### OUTPUT TEMPLATE\n{\"lead_system\": <\"10-20\"|\"10-10\"|\"10-5\"|null>, \"non_standard_channels\": }", + "metrics": [ + { + "metric_id": "lead_system_accuracy", + "type": "categorical_check", + "target_key": "lead_system", + "weight": 50, + "params": { + "gt_value": "10-10" + } + }, + { + "metric_id": "non_standard_channels_match", + "type": "set_match_check", + "target_key": "non_standard_channels", + "weight": 50, + "params": { + "gt_value": [ + "M1", + "M2", + "CB1", + "CB2", + "VEO", + "HEO" + ], + "match_mode": "exact" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case07/case07_04.json b/foundational_analysis/cases/case07/case07_04.json new file mode 100644 index 0000000000000000000000000000000000000000..85210fbd290a07c3894d468348c92b461d7dd173 --- /dev/null +++ b/foundational_analysis/cases/case07/case07_04.json @@ -0,0 +1,40 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please determine which lead-distribution system this recording follows (10-20, 10-10 or 10-5), and then list all channels that do not belong to standard measurement electrodes of that system. Return the non-standard channels using their original channel names exactly as they appear in the data. If all channels belong to standard measurement electrodes, return an empty list." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two outputs from the agent report:\n1) lead system classification\n2) final list of channels that are not standard measurement electrodes of that system\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The keys in JSON must be EXACTLY \"lead_system\" and \"non_standard_channels\".\n5. \"lead_system\" must be exactly one of \"10-20\", \"10-10\", \"10-5\", or null.\n6. Extract the explicitly reported final non-standard-channel list, not the full channel inventory or the standard-channel list.\n7. Normalize each returned display name only to the benchmark naming contract: trim whitespace and remove one leading acquisition prefix EEG followed by a space, hyphen, or underscore.\n8. If a modality prefix is immediately duplicated, collapse it to one label; for example, \"ECG ECG\" becomes \"ECG\". Preserve the remaining spelling, case, punctuation, and reference identity exactly.\n9. Do NOT remove terminal reference parts and do NOT convert legacy aliases for this case. Required examples: \"EEG A2-A1\" -> \"A2-A1\"; \"EEG 23A-23R\" -> \"23A-23R\"; \"ECG ECG\" -> \"ECG\"; \"SaO2\" -> \"SaO2\".\n10. If the report explicitly says no non-standard channel exists, return an empty array []. If the final list is missing or unclear, set non_standard_channels to null.\n11. If lead_system is missing or unclear, set only lead_system to null; do not guess either value.\n\n### OUTPUT TEMPLATE\n{\"lead_system\": <\"10-20\"|\"10-10\"|\"10-5\"|null>, \"non_standard_channels\": }", + "metrics": [ + { + "metric_id": "lead_system_accuracy", + "type": "categorical_check", + "target_key": "lead_system", + "weight": 50, + "params": { + "gt_value": "10-20" + } + }, + { + "metric_id": "non_standard_channels_match", + "type": "set_match_check", + "target_key": "non_standard_channels", + "weight": 50, + "params": { + "gt_value": [ + "A2-A1", + "23A-23R", + "24A-24R" + ], + "match_mode": "exact" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case07/case07_05.json b/foundational_analysis/cases/case07/case07_05.json new file mode 100644 index 0000000000000000000000000000000000000000..e3dff11abfb0d8199d2804879629a6f5ca95d362 --- /dev/null +++ b/foundational_analysis/cases/case07/case07_05.json @@ -0,0 +1,39 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please determine which lead-distribution system this recording follows (10-20, 10-10 or 10-5), and then list all channels that do not belong to standard measurement electrodes of that system. Return the non-standard channels using their original channel names exactly as they appear in the data. If all channels belong to standard measurement electrodes, return an empty list." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract two outputs from the agent report:\n1) lead system classification\n2) final list of channels that are not standard measurement electrodes of that system\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The keys in JSON must be EXACTLY \"lead_system\" and \"non_standard_channels\".\n5. \"lead_system\" must be exactly one of \"10-20\", \"10-10\", \"10-5\", or null.\n6. Extract the explicitly reported final non-standard-channel list, not the full channel inventory or the standard-channel list.\n7. Normalize each returned display name only to the benchmark naming contract: trim whitespace and remove one leading acquisition prefix EEG followed by a space, hyphen, or underscore.\n8. If a modality prefix is immediately duplicated, collapse it to one label; for example, \"ECG ECG\" becomes \"ECG\". Preserve the remaining spelling, case, punctuation, and reference identity exactly.\n9. Do NOT remove terminal reference parts and do NOT convert legacy aliases for this case. Required examples: \"EEG A2-A1\" -> \"A2-A1\"; \"EEG 23A-23R\" -> \"23A-23R\"; \"ECG ECG\" -> \"ECG\"; \"SaO2\" -> \"SaO2\".\n10. If the report explicitly says no non-standard channel exists, return an empty array []. If the final list is missing or unclear, set non_standard_channels to null.\n11. If lead_system is missing or unclear, set only lead_system to null; do not guess either value.\n\n### OUTPUT TEMPLATE\n{\"lead_system\": <\"10-20\"|\"10-10\"|\"10-5\"|null>, \"non_standard_channels\": }", + "metrics": [ + { + "metric_id": "lead_system_accuracy", + "type": "categorical_check", + "target_key": "lead_system", + "weight": 50, + "params": { + "gt_value": "10-20" + } + }, + { + "metric_id": "non_standard_channels_match", + "type": "set_match_check", + "target_key": "non_standard_channels", + "weight": 50, + "params": { + "gt_value": [ + "A2-A1", + "ECG" + ], + "match_mode": "exact" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case08/case08_01.json b/foundational_analysis/cases/case08/case08_01.json new file mode 100644 index 0000000000000000000000000000000000000000..f334abfff54b581b2752009a281ea06779d13dcc --- /dev/null +++ b/foundational_analysis/cases/case08/case08_01.json @@ -0,0 +1,26 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please judge whether this EEG recording is suitable for spectral asymmetry analysis (left-vs-right spectral asymmetry). Your final answer must be exactly one word: \"Yes\" or \"No\"." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final suitability decision for spectral asymmetry analysis.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The key in JSON must be EXACTLY \"asymmetry_suitable\".\n5. The value must be exactly \"Yes\" or \"No\".\n6. If missing or unclear, return {\"asymmetry_suitable\": null}.\n\n### OUTPUT TEMPLATE\n{\"asymmetry_suitable\": <\"Yes\"|\"No\"|null>}", + "metrics": [ + { + "metric_id": "asymmetry_suitability_accuracy", + "type": "categorical_check", + "target_key": "asymmetry_suitable", + "weight": 100, + "params": { + "gt_value": "Yes" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case08/case08_02.json b/foundational_analysis/cases/case08/case08_02.json new file mode 100644 index 0000000000000000000000000000000000000000..638a9aea4f077f6ef2a066204a1950bb4d01361f --- /dev/null +++ b/foundational_analysis/cases/case08/case08_02.json @@ -0,0 +1,26 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please judge whether this EEG recording is suitable for spectral asymmetry analysis (left-vs-right spectral asymmetry). Your final answer must be exactly one word: \"Yes\" or \"No\"." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final suitability decision for spectral asymmetry analysis.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The key in JSON must be EXACTLY \"asymmetry_suitable\".\n5. The value must be exactly \"Yes\" or \"No\".\n6. If missing or unclear, return {\"asymmetry_suitable\": null}.\n\n### OUTPUT TEMPLATE\n{\"asymmetry_suitable\": <\"Yes\"|\"No\"|null>}", + "metrics": [ + { + "metric_id": "asymmetry_suitability_accuracy", + "type": "categorical_check", + "target_key": "asymmetry_suitable", + "weight": 100, + "params": { + "gt_value": "Yes" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case08/case08_03.json b/foundational_analysis/cases/case08/case08_03.json new file mode 100644 index 0000000000000000000000000000000000000000..e9c05908128b1b726ac772502f18e1ab822e4f6c --- /dev/null +++ b/foundational_analysis/cases/case08/case08_03.json @@ -0,0 +1,26 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please judge whether this EEG recording is suitable for spectral asymmetry analysis (left-vs-right spectral asymmetry). Your final answer must be exactly one word: \"Yes\" or \"No\"." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final suitability decision for spectral asymmetry analysis.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The key in JSON must be EXACTLY \"asymmetry_suitable\".\n5. The value must be exactly \"Yes\" or \"No\".\n6. If missing or unclear, return {\"asymmetry_suitable\": null}.\n\n### OUTPUT TEMPLATE\n{\"asymmetry_suitable\": <\"Yes\"|\"No\"|null>}", + "metrics": [ + { + "metric_id": "asymmetry_suitability_accuracy", + "type": "categorical_check", + "target_key": "asymmetry_suitable", + "weight": 100, + "params": { + "gt_value": "Yes" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case08/case08_04.json b/foundational_analysis/cases/case08/case08_04.json new file mode 100644 index 0000000000000000000000000000000000000000..1bf92f291d83c4143b4ef088f15a5865d06ed5da --- /dev/null +++ b/foundational_analysis/cases/case08/case08_04.json @@ -0,0 +1,26 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please judge whether this EEG recording is suitable for spectral asymmetry analysis (left-vs-right spectral asymmetry). Your final answer must be exactly one word: \"Yes\" or \"No\"." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final suitability decision for spectral asymmetry analysis.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The key in JSON must be EXACTLY \"asymmetry_suitable\".\n5. The value must be exactly \"Yes\" or \"No\".\n6. If missing or unclear, return {\"asymmetry_suitable\": null}.\n\n### OUTPUT TEMPLATE\n{\"asymmetry_suitable\": <\"Yes\"|\"No\"|null>}", + "metrics": [ + { + "metric_id": "asymmetry_suitability_accuracy", + "type": "categorical_check", + "target_key": "asymmetry_suitable", + "weight": 100, + "params": { + "gt_value": "Yes" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case08/case08_05.json b/foundational_analysis/cases/case08/case08_05.json new file mode 100644 index 0000000000000000000000000000000000000000..86d7a47cf49bc153f297f229e809d6b162ed3c4b --- /dev/null +++ b/foundational_analysis/cases/case08/case08_05.json @@ -0,0 +1,26 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.0, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please judge whether this EEG recording is suitable for spectral asymmetry analysis (left-vs-right spectral asymmetry). Your final answer must be exactly one word: \"Yes\" or \"No\"." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final suitability decision for spectral asymmetry analysis.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include conversational text or explanations.\n4. The key in JSON must be EXACTLY \"asymmetry_suitable\".\n5. The value must be exactly \"Yes\" or \"No\".\n6. If missing or unclear, return {\"asymmetry_suitable\": null}.\n\n### OUTPUT TEMPLATE\n{\"asymmetry_suitable\": <\"Yes\"|\"No\"|null>}", + "metrics": [ + { + "metric_id": "asymmetry_suitability_accuracy", + "type": "categorical_check", + "target_key": "asymmetry_suitable", + "weight": 100, + "params": { + "gt_value": "Yes" + } + } + ] + } +} \ No newline at end of file diff --git a/foundational_analysis/cases/case09/case09_01.json b/foundational_analysis/cases/case09/case09_01.json new file mode 100644 index 0000000000000000000000000000000000000000..f3422b45120b1709264b492786a86aa826ff733a --- /dev/null +++ b/foundational_analysis/cases/case09/case09_01.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "ISRUC_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_01.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "C4-F4", + "F3-F4", + "C4-O2" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_02.json b/foundational_analysis/cases/case09/case09_02.json new file mode 100644 index 0000000000000000000000000000000000000000..569698d827b23a0c9555f6a21c2cdb1b4ac262e2 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_02.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "ISRUC_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_02.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "C4-F4", + "C3-F3", + "F3-F4" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_03.json b/foundational_analysis/cases/case09/case09_03.json new file mode 100644 index 0000000000000000000000000000000000000000..8b3b05551c92dc07d1eed690199c58e17c61cbd4 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_03.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "ISRUC_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_03.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "C3-F3", + "C4-F4", + "F3-F4" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_04.json b/foundational_analysis/cases/case09/case09_04.json new file mode 100644 index 0000000000000000000000000000000000000000..a44b17ad1c57bf60aff72b811b7e76f5ef5c947c --- /dev/null +++ b/foundational_analysis/cases/case09/case09_04.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "ISRUC_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_04.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "C3-F3", + "C4-F4", + "F3-F4" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_05.json b/foundational_analysis/cases/case09/case09_05.json new file mode 100644 index 0000000000000000000000000000000000000000..e7e9503eb9704c9d1cb8b82cae058459b887a9c6 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_05.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "ISRUC_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "ISRUC" + }, + "agent_input": { + "data_path": "data/core/ISRUC_05.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "C3-F3", + "C4-F4", + "C4-O2" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_06.json b/foundational_analysis/cases/case09/case09_06.json new file mode 100644 index 0000000000000000000000000000000000000000..4bdbe78216afd2443c05d4756170b27d85192ee4 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_06.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_01.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "P3-P5", + "CPZ-PZ", + "P6-PO4" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_07.json b/foundational_analysis/cases/case09/case09_07.json new file mode 100644 index 0000000000000000000000000000000000000000..78f20809c729c41f2507ded265a65d73d3e502c2 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_07.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_02.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "F5-F7", + "AF4-F4", + "CP6-P8" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_08.json b/foundational_analysis/cases/case09/case09_08.json new file mode 100644 index 0000000000000000000000000000000000000000..020d99ad17e6b23e10dab9313877edc73966c695 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_08.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_03.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "AF7-F5", + "F5-F7", + "AF7-F7" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_09.json b/foundational_analysis/cases/case09/case09_09.json new file mode 100644 index 0000000000000000000000000000000000000000..c2a888c4479a6b939701b1639bde44f7133fcbf0 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_09.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_04.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "F7-FT7", + "F4-F6", + "P4-P6" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_10.json b/foundational_analysis/cases/case09/case09_10.json new file mode 100644 index 0000000000000000000000000000000000000000..80e3420540845d1480678a750b771373c2e44673 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_10.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "BCIC2020-3_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "BCIC2020-3" + }, + "agent_input": { + "data_path": "data/core/BCIC2020-3_05.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "P3-P5", + "P1-P3", + "P4-PO8" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_11.json b/foundational_analysis/cases/case09/case09_11.json new file mode 100644 index 0000000000000000000000000000000000000000..5657c4d31b86148fbbcc601c04e10499b84fe112 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_11.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "SEED-V-01.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-01.cnt", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "AF3-FP1", + "AF4-FP2", + "FP2-FPZ" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_12.json b/foundational_analysis/cases/case09/case09_12.json new file mode 100644 index 0000000000000000000000000000000000000000..fb0d92de2876045bdd718de2249eec45f3e508bb --- /dev/null +++ b/foundational_analysis/cases/case09/case09_12.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "SEED-V-02.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-02.cnt", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "PO3-PO5", + "P8-PO8", + "CB1-O1" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_13.json b/foundational_analysis/cases/case09/case09_13.json new file mode 100644 index 0000000000000000000000000000000000000000..d5b3cced2298aa1187bb1d54e011f0394ff933d2 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_13.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "SEED-V-03.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-03.cnt", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "PO4-PO6", + "FP2-FPZ", + "P4-P6" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_14.json b/foundational_analysis/cases/case09/case09_14.json new file mode 100644 index 0000000000000000000000000000000000000000..4681ed4c31f324fde3dafd130d69a86cc8137a15 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_14.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "SEED-V-04.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-04.cnt", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "O2-PO4", + "PO6-PO8", + "P4-P6" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_15.json b/foundational_analysis/cases/case09/case09_15.json new file mode 100644 index 0000000000000000000000000000000000000000..d04d07c7e39f7189d7eade9e15dfe095c5c45e22 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_15.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "SEED-V-05.cnt", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "SEED-V" + }, + "agent_input": { + "data_path": "data/core/SEED-V-05.cnt", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "P4-P6", + "AF3-FP1", + "FP2-FPZ" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_16.json b/foundational_analysis/cases/case09/case09_16.json new file mode 100644 index 0000000000000000000000000000000000000000..a6c3a56421e64df7652f616f369dd490c9d65b46 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_16.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_01.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "FP1-FP2", + "F4-FZ", + "F3-FZ" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_17.json b/foundational_analysis/cases/case09/case09_17.json new file mode 100644 index 0000000000000000000000000000000000000000..6d8c164665062996bcf1325b5a8a517c26fd706d --- /dev/null +++ b/foundational_analysis/cases/case09/case09_17.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_02.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "P3-P7", + "T7-T8", + "F3-FP1" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_18.json b/foundational_analysis/cases/case09/case09_18.json new file mode 100644 index 0000000000000000000000000000000000000000..8e6c4ebcc3fa37a266f1059c52955f2a84962d8f --- /dev/null +++ b/foundational_analysis/cases/case09/case09_18.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_03.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "F4-FZ", + "F3-FZ", + "FP1-FP2" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_19.json b/foundational_analysis/cases/case09/case09_19.json new file mode 100644 index 0000000000000000000000000000000000000000..448926e9d1bd8b0ad6ce60f4ed85636fe2588265 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_19.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_04.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "FP1-FZ", + "P4-P8", + "P3-P7" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_20.json b/foundational_analysis/cases/case09/case09_20.json new file mode 100644 index 0000000000000000000000000000000000000000..753528b2953f7ce45221e5e88dab9c65c32f46f6 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_20.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "Mumtaz2016_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "Mumtaz2016" + }, + "agent_input": { + "data_path": "data/core/Mumtaz2016_05.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "P3-P7", + "O1-P7", + "C4-CZ" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_21.json b/foundational_analysis/cases/case09/case09_21.json new file mode 100644 index 0000000000000000000000000000000000000000..34d8fbf3aa15b219be43bd93284283248bd92843 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_21.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_01.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_01.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "F4-FZ", + "FP1-FP2", + "F3-FP1" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_22.json b/foundational_analysis/cases/case09/case09_22.json new file mode 100644 index 0000000000000000000000000000000000000000..eaedb65e09e37c165b3720012bef8e9b071c2242 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_22.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_02.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_02.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "F7-FP1", + "FP1-FP2", + "F3-FZ" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_23.json b/foundational_analysis/cases/case09/case09_23.json new file mode 100644 index 0000000000000000000000000000000000000000..6aa27763cf2d1f4579fbd0ff866856af5f0d4ca5 --- /dev/null +++ b/foundational_analysis/cases/case09/case09_23.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_03.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_03.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "P3-PZ", + "C4-CZ", + "C3-CZ" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_24.json b/foundational_analysis/cases/case09/case09_24.json new file mode 100644 index 0000000000000000000000000000000000000000..83bfc2e7ed9486a9a371445f9a72143c005211ee --- /dev/null +++ b/foundational_analysis/cases/case09/case09_24.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_04.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_04.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "F3-FZ", + "F4-FZ", + "O2-P4" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +} diff --git a/foundational_analysis/cases/case09/case09_25.json b/foundational_analysis/cases/case09/case09_25.json new file mode 100644 index 0000000000000000000000000000000000000000..efdea2e644100932b716de45454cd366729e581a --- /dev/null +++ b/foundational_analysis/cases/case09/case09_25.json @@ -0,0 +1,32 @@ +{ + "meta_info": { + "case_id": "MentalArithmetic_05.edf", + "bench_subset": "NeuroBench-Core", + "difficult": 1.5, + "original_dataset": "MentalArithmetic" + }, + "agent_input": { + "data_path": "data/core/MentalArithmetic_05.edf", + "instruction": "Please select EEG channels from the raw signal, apply a 0.5-40Hz FIR bandpass filter, compute pairwise Pearson correlation coefficients between EEG channels, and then return the top 3 channel pairs sorted by coefficient from highest to lowest. Report only channel pairs in descending order." + }, + "eval_config": { + "parser_prompt": "### ROLE\nYou are a precise JSON Extraction Engine for neurophysiological data. Your sole task is to convert natural language reports into structured JSON data.\n\n### TASK\nExtract the final Top-3 channel-pair sequence ranked by Pearson correlation coefficient from high to low.\n\n### STRICT CONSTRAINTS (MANDATORY)\n1. Output ONLY a valid JSON object.\n2. DO NOT include Markdown code blocks.\n3. DO NOT include any conversational text or explanations.\n4. The key in JSON must be EXACTLY \"top3_pairs\".\n5. The value of \"top3_pairs\" must be an array of exactly 3 strings.\n6. Normalize EACH reported pair independently. First identify the two complete source channel labels; a referenced label such as F4-A1 is one complete channel label, and its hyphen must not be treated as the pair separator.\n7. For each source channel separately, uppercase it and remove one terminal reference suffix if present: -A1, -A2, -LE, -REF, -M1, -M2, or -AVG. Never output a reference electrode (A1/A2/LE/REF/M1/M2/AVG) as a pair member.\n8. Convert legacy aliases after removing the reference suffix: T3->T7, T4->T8, T5->P7, T6->P8.\n9. Sort the two normalized channel labels in ascending lexicographic order, then join them with exactly one hyphen using format \"CH1-CH2\" (uppercase, no spaces). If the report already uses a canonical pair such as F4-C4, normalize it to C4-F4. Each final label may contain only uppercase A-Z letters and digits; mixed-case forms such as Fp1 or Fp2 are forbidden and must become FP1 or FP2.\n10. Required examples: \"F4-A1 and C4-A1\" -> \"C4-F4\"; \"F4-C4\" -> \"C4-F4\"; \"T4-A1 and T3-A2\" -> \"T7-T8\"; \"Fp2 and Fp1\" -> \"FP1-FP2\".\n11. Preserve the three pairs in descending correlation order as reported. Do not sort the three-element array lexicographically.\n12. If any pair cannot be resolved into exactly two non-reference channels, return {\"top3_pairs\": null}; do not guess.\n\n### OUTPUT TEMPLATE\n{\"top3_pairs\": [\"CH1-CH2\", \"CH3-CH4\", \"CH5-CH6\"]}", + "metrics": [ + { + "metric_id": "top3_corr_pairs_sequence", + "type": "sequence_match_check", + "target_key": "top3_pairs", + "weight": 100, + "params": { + "gt_value": [ + "F8-FP2", + "F7-FP1", + "F3-FP1" + ], + "match_mode": "exact_order", + "top_k": 3 + } + } + ] + } +}