Add files using upload-large-folder tool

README.md

@@ -20,7 +20,7 @@ size_categories:
 
 Percept-V is a benchmark of **30 synthetic visual perception tasks**, 200 samples each (**6,000 samples total**), designed to isolate *perception* from *reasoning* in vision-language models. Every task is procedurally generated from simple primitives — circles, lines, grids, shapes, colours — so a model that genuinely sees the image should solve it near-perfectly, and failures point at perceptual rather than reasoning limits.
 
-Tasks span counting, colour identification, shape identification, spatial localisation, layering/occlusion, grid navigation, and two-image comparison.
+Tasks span counting, colour identification, shape identification, spatial localisation, layering/occlusion, grid navigation, and two-image comparison. Each task ships with its images, ground truth, prompts, and the exact parsing and scoring scripts used to evaluate it.
 
 ## Repository layout
 
@@ -31,10 +31,12 @@ Each task is a self-contained directory:
 ├── data/                    # 200 images (or 400 for two-image tasks)
 │   ├── 1.png ... 200.png
 ├── data.json                # 200 ground-truth records, one per sample
-└── prompts/
-    ├── input_prompt.txt     # describes what the image contains
-    ├── rules.txt            # the task the model must perform
-    └── output_prompt.txt    # required output format
+├── prompts/
+│   ├── input_prompt.txt     # describes what the image contains
+│   ├── rules.txt            # the task the model must perform
+│   └── output_prompt.txt    # required output format
+├── utils.py                 # parses raw model text into a structured answer
+└── eval.py                  # scores parsed answers against the ground truth
 ```
 
 ### Prompt construction
@@ -64,38 +66,40 @@ In both cases the partner image is recovered from the `id` by swapping the prefi
 
 ## Tasks
 
-| Task | Images/sample | `id` format | `data.json` fields |
-|---|---|---|---|
-| `change_colour` | 2 | `second1.png` | `num_differences` |
-| `circle_boxes` | 1 | `1.png` | `answer`, `num_objects` |
-| `circle_location` | 1 | `1.png` | `count`, `num_objects`, `quadrant` |
-| `circle_right_triangle` | 1 | `1.png` | `circles`, `cols`, `right`, `rows`, `triangles` |
-| `colours_present` | 2 | `1.png` | `colours_present`, `num_objects` |
-| `comparing_size` | 1 | `1.png` | `Gold_output`, `Rows` |
-| `count_coloured_circles` | 1 | `1.png` | `num_objects`, `red_circle` |
-| `counting_circles` | 1 | `1.png` | `num_objects` |
-| `counting_locations` | 1 | `1.png` | `num_objects_over_table`, `num_objects_under_table` |
-| `counting_shapes` | 1 | `1.png` | `circles`, `squares`, `triangles` |
-| `cross_and_knots` | 1 | `1.png` | `cross_positions`, `crosses`, `gold_output`, `n` |
-| `graph_counting` | 1 | `1.png` | `num_edges`, `num_nodes` |
-| `grid_path` | 1 | `1.png` | `gold_output`, `path_size`, `rows` |
-| `identifying_shapes` | 1 | `1.png` | `Gold_output`, `Gold_side`, `Rows` |
-| `inside_circles` | 1 | `1.png` | `inside_circles`, `num_circles` |
-| `layered_colours` | 1 | `1.png` | `colors`, `num_layers` |
-| `layered_shapes` | 1 | `1.png` | `num_layers`, `order` |
-| `list_colours` | 1 | `1.png` | `list_colours`, `num_objects` |
-| `list_shapes` | 1 | `1.png` | `list_shapes`, `num_objects` |
-| `locate_circles_colour` | 1 | `1.png` | `gold_output`, `n_circles`, `rows` |
-| `locate_circles_shape` | 1 | `1.png` | `gold_output`, `n_circles`, `rows` |
-| `match_outline` | 2 | `second1.png` | `Gold_output`, `Rows` |
-| `match_shadow` | 2 | `second1.png` | `Gold_output`, `Rows` |
-| `maze_solving` | 1 | `1.png` | `Columns`, `Rows`, `path` |
-| `mirror_image` | 2 | `second1.png` | `mirror_image`, `num_objects` |
-| `numbered_shapes` | 1 | `1.png` | `circles`, `num_objects`, `pentagons`, `rectangles`, `triangles` |
-| `sort_circles` | 1 | `1.png` | `Gold_output`, `Rows` |
-| `sort_lines` | 1 | `1.png` | `Gold_output`, `Lines` |
-| `vanishing_objects` | 2 | `second1.png` | `circles`, `squares`, `triangles`, `vanished` |
-| `water_image` | 2 | `second1.png` | `num_objects`, `water_image` |
+The last column is the field `eval.py` buckets by when reporting category-wise accuracy — in practice a difficulty axis for that task.
+
+| Task | Images/sample | `id` format | `data.json` fields | Difficulty axis |
+|---|---|---|---|---|
+| `change_colour` | 2 | `second1.png` | `num_differences` | `num_differences` |
+| `circle_boxes` | 1 | `1.png` | `answer`, `num_objects` | `num_objects` |
+| `circle_location` | 1 | `1.png` | `count`, `num_objects`, `quadrant` | `num_objects` |
+| `circle_right_triangle` | 1 | `1.png` | `circles`, `cols`, `right`, `rows`, `triangles` | `rows` |
+| `colours_present` | 2 | `1.png` | `colours_present`, `num_objects` | `num_objects` |
+| `comparing_size` | 1 | `1.png` | `Gold_output`, `Rows` | `Rows` |
+| `count_coloured_circles` | 1 | `1.png` | `num_objects`, `red_circle` | `num_objects` |
+| `counting_circles` | 1 | `1.png` | `num_objects` | `num_objects` |
+| `counting_locations` | 1 | `1.png` | `num_objects_over_table`, `num_objects_under_table` | `num_objects_over_table` |
+| `counting_shapes` | 1 | `1.png` | `circles`, `squares`, `triangles` | `circles` |
+| `cross_and_knots` | 1 | `1.png` | `cross_positions`, `crosses`, `gold_output`, `n` | `n` |
+| `graph_counting` | 1 | `1.png` | `num_edges`, `num_nodes` | `num_nodes` |
+| `grid_path` | 1 | `1.png` | `gold_output`, `path_size`, `rows` | `rows` |
+| `identifying_shapes` | 1 | `1.png` | `Gold_output`, `Gold_side`, `Rows` | `Rows` |
+| `inside_circles` | 1 | `1.png` | `inside_circles`, `num_circles` | `num_circles` |
+| `layered_colours` | 1 | `1.png` | `colors`, `num_layers` | `num_layers` |
+| `layered_shapes` | 1 | `1.png` | `num_layers`, `order` | `num_layers` |
+| `list_colours` | 1 | `1.png` | `list_colours`, `num_objects` | `num_objects` |
+| `list_shapes` | 1 | `1.png` | `list_shapes`, `num_objects` | `num_objects` |
+| `locate_circles_colour` | 1 | `1.png` | `gold_output`, `n_circles`, `rows` | `n_circles` |
+| `locate_circles_shape` | 1 | `1.png` | `gold_output`, `n_circles`, `rows` | `n_circles` |
+| `match_outline` | 2 | `second1.png` | `Gold_output`, `Rows` | `Rows` |
+| `match_shadow` | 2 | `second1.png` | `Gold_output`, `Rows` | `Rows` |
+| `maze_solving` | 1 | `1.png` | `Columns`, `Rows`, `path` | `len(path) - 2` |
+| `mirror_image` | 2 | `second1.png` | `mirror_image`, `num_objects` | `num_objects` |
+| `numbered_shapes` | 1 | `1.png` | `circles`, `num_objects`, `pentagons`, `rectangles`, `triangles` | `num_objects` |
+| `sort_circles` | 1 | `1.png` | `Gold_output`, `Rows` | `Rows` |
+| `sort_lines` | 1 | `1.png` | `Gold_output`, `Lines` | `Lines` |
+| `vanishing_objects` | 2 | `second1.png` | `circles`, `squares`, `triangles`, `vanished` | `circles` |
+| `water_image` | 2 | `second1.png` | `num_objects`, `water_image` | `num_objects` |
 
 ## Usage
 
@@ -135,7 +139,66 @@ To fetch a single task instead of all 226 MB, pass `allow_patterns="counting_cir
 
 ## Evaluation
 
-Parse the **last line** of the model's response and compare it against the answer field for that task. Because answer-field names and formats differ per task, exact-match scoring needs a small per-task normaliser.
+Each task ships the two scripts used to produce the numbers in the paper: `utils.py` (answer parsing) and `eval.py` (scoring). They are per-task — parsing and correctness rules differ across tasks — so always use the pair from the task directory you are scoring. Both are plain Python with no dependencies beyond the standard library.
+
+Evaluation runs in three steps.
+
+**1. Inference.** For each sample, build the prompt and record the model's raw text in a field named `gpt_response`, alongside all the original `data.json` fields. Write the list to `answer_<model>.json`:
+
+```json
+[
+  {"id": "1.png", "num_objects": 1, "gpt_response": "COUNT:1"},
+  ...
+]
+```
+
+**2. Parse.** `utils.output_from_text(text)` extracts the structured answer from the raw response, returning `{"OUTPUT": ..., "ERROR": ...}`. `OUTPUT` is `None` and `ERROR` is set when the response does not follow the format required by `output_prompt.txt`. Copy these into `Output` and `ERROR` on each record:
+
+```python
+import json, importlib.util
+
+task = "counting_circles"
+spec = importlib.util.spec_from_file_location("u", f"{task}/utils.py")
+utils = importlib.util.module_from_spec(spec); spec.loader.exec_module(utils)
+
+records = json.load(open(f"{task}/answer_mymodel.json"))
+for r in records:
+    parsed = utils.output_from_text(r["gpt_response"])
+    r["Output"], r["ERROR"] = parsed["OUTPUT"], parsed["ERROR"]
+json.dump(records, open(f"{task}/answer_mymodel.json", "w"), indent=4)
+```
+
+**3. Score.**
+
+```bash
+python counting_circles/eval.py \
+    -a counting_circles/answer_mymodel.json \
+    -o counting_circles/eval_mymodel.json
+```
+
+`eval.py` compares `Output` against the ground-truth fields already present in each record and writes:
+
+```json
+{
+  "Overall Accuracy": 42.5,
+  "Category-wise Accuracy": {
+    "1": 100.0, "2": 100.0, "3": 90.0, "4": 100.0, "5": 70.0,
+    "...": "...",
+    "16": 10.0, "17": 10.0, "18": 0.0, "19": 0.0, "20": 20.0
+  }
+}
+```
+
+The shape of that result is typical: near-ceiling on the smallest instances, collapsing as the count grows — which is the separation between perception and reasoning the benchmark is built to expose.
+
+Unparseable responses (`Output` absent or `None`) count as incorrect rather than being dropped, so `Overall Accuracy` is over all 200 samples and format failures are penalised. The category keys are the difficulty axis listed in the table above.
+
+Eight tasks — `circle_right_triangle`, `cross_and_knots`, `graph_counting`, `grid_path`, `identifying_shapes`, `inside_circles`, `maze_solving`, `sort_circles` — additionally expose `gold_to_output(i)` in `utils.py`, which renders the gold answer for sample `i` in the exact format `output_prompt.txt` asks for. This is useful for building few-shot exemplars.
+
+### Notes
+
+- `eval.py` takes `--answer`/`-a` and `--output`/`-o`; the defaults refer to files that are not shipped here, so pass both explicitly.
+- Several `utils.py` files contain a second, commented-out `output_from_text` inside a triple-quoted string, left over from earlier prompt formats. Only the live top-level definition is used.
 
 ## Licence
 

circle_right_triangle/eval.py

@@ -0,0 +1,139 @@
+import json
+
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer_gpt4o.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval_gpt4o.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+
+    for entry in data:
+        grid_size = entry['rows']
+        num_circles = entry['circles']
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        #if grid_size not in category_accuracies:
+        #    category_accuracies[grid_size] = {'correct': 0  , 'total': 0}
+        
+        if num_circles not in category_accuracies:
+            category_accuracies[num_circles] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_circles]['total'] += 1
+        #category_accuracies['total'] += 1
+        # category_accuracies[(grid_size,num_circles)]['total'] += 1
+
+        if entry["ERROR"]:
+            continue
+
+        # Check if the output is correct
+        output = entry["Output"]
+
+        if output == entry["right"]:
+            correct_counts += 1
+            #category_accuracies['correct'] += 1
+            category_accuracies[num_circles]['correct'] += 1
+        
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")
+
+    
+    """for entry in data:
+        grid_size = entry['rows']
+        num_circles = entry['circles']
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if grid_size not in category_accuracies:
+            category_accuracies[grid_size] = {'correct': 0  , 'total': 0}
+        
+        if num_circles not in category_accuracies[grid_size]:
+            category_accuracies[grid_size][num_circles] = {'correct': 0, 'total': 0}
+
+        category_accuracies[grid_size][num_circles]['total'] += 1
+        category_accuracies[grid_size]['total'] += 1
+        # category_accuracies[(grid_size,num_circles)]['total'] += 1
+
+        if entry["ERROR"]:
+            continue
+
+        # Check if the output is correct
+        output = entry["Output"]
+
+        if output == entry["right"]:
+            correct_counts += 1
+            category_accuracies[grid_size]['correct'] += 1
+            category_accuracies[grid_size][num_circles]['correct'] += 1
+        
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    for grid_size in category_accuracies:
+        category_accuracies[grid_size]["Accuracy"] = category_accuracies[grid_size]['correct'] / category_accuracies[grid_size]['total'] * 100
+        for num_queens in category_accuracies[grid_size]:
+            if num_queens == 'correct' or num_queens == 'total' or num_queens == 'Accuracy':
+                continue
+            # print(category_accuracies[grid_size][num_queens])
+            category_accuracies[grid_size][num_queens]["Accuracy"] = category_accuracies[grid_size][num_queens]['correct'] / category_accuracies[grid_size][num_queens]['total'] * 100
+        
+
+            
+
+    # category_accuracies["Overall Accuracy"] = overall_accuracy
+
+    final_results = {}
+    for grid_size in category_accuracies:
+        # print(grid_size)    
+        final_results[grid_size] = {}
+        final_results[grid_size]["Overall Accuracy"] = category_accuracies[grid_size]["Accuracy"]
+        final_results[grid_size]["Category-wise Accuracy"] = {}
+        for num_crosses in category_accuracies[grid_size]:
+            if num_crosses == 'correct' or num_crosses == 'total' or num_crosses == 'Accuracy':
+                continue
+            final_results[grid_size]["Category-wise Accuracy"][num_crosses] = category_accuracies[grid_size][num_crosses]["Accuracy"]
+
+    final_results["Overall Accuracy"] = overall_accuracy
+
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(final_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")"""

circle_right_triangle/utils.py

@@ -0,0 +1,84 @@
+import re
+import json
+
+def output_from_text(output_text):
+
+    try:
+        output_text = output_text.split('\n')
+        # print(output_text)
+        if len(output_text) < 2:
+            out_line = output_text[-1].strip()
+        else:
+            out_line = output_text[-2].strip()
+        
+        try:
+            match = re.search(r'\s*(yes|no)\s*', out_line.lower(), re.IGNORECASE)
+            if match:
+                return {
+                    "OUTPUT": (match.group(1).capitalize() == "Yes"),
+                    "ERROR": None
+                }
+            else:
+                out_line = output_text[-1].strip()
+                match = re.search(r'\s*(yes|no)\s*', out_line, re.IGNORECASE)
+                if match:
+                    return {
+                    "OUTPUT": (match.group(1).capitalize() == "Yes"),
+                    "ERROR": None
+                }
+                else:
+                    return {
+                        "OUTPUT": None,
+                        "ERROR": "Output file should have last line as either 'yes' or 'no'"
+                    }
+        except Exception as e:
+            return {
+                "OUTPUT": None,
+                "ERROR": f"Unexpected error while parsing {str(e)}\n"
+            }
+    except Exception as e:
+
+        return {
+            "OUTPUT": None,
+            "ERROR": f"Unexpected error while parsing {str(e)}\n"
+        }
+    
+
+import os
+import json
+def gold_to_output(i):
+    gold_output = None
+    try:
+        #get directory of this file
+        dir_of_file = os.path.dirname(os.path.realpath(__file__))
+        #open the data file
+        with open(dir_of_file + "\data.json") as f:
+            data = json.load(f)
+        row = data[i]
+        ans = row['right']
+        output_prompt = "YES" if ans else "NO"
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }
+    
+    return {
+        "OUTPUT": output_prompt,
+        "ERROR": None
+    }
+
+
+# # # Test the function
+# with open("./answer.json", "r") as f:
+#     data = json.load(f)
+#     # print(data[1])
+#     for i in data:
+#         output_text = i["gpt_response"]
+
+#         i["Output"] = output_from_text(output_text)["OUTPUT"]
+#         i["ERROR"] = output_from_text(output_text)["ERROR"]
+    
+#     with open("./answer.json", "w") as f:
+#         json.dump(data, f, indent=4)
+#         print("Output saved to answer.json")

colours_present/utils.py

@@ -0,0 +1,30 @@
+import re
+
+def output_from_text(text):
+    #extract the number in the last line of text
+    try:
+        lines = text.strip().split("\n")
+        lines = list(filter(None, lines))
+        last_line = list(filter(None, lines[-1].split(" ")))
+        #last_line = [x.lower() for x in last_line]
+        answer = []
+        for x in last_line:
+            word = re.sub(r'[^a-zA-Z]', '', x.lower())
+            if word == 'no' or word == 'yes':
+                answer.append(word)
+
+        if answer != []:
+            return {
+                "OUTPUT": answer,
+                "ERROR": None
+            }
+        else:
+            return{
+                "OUTPUT": None,
+                "ERROR": 'Does not give yes/no answer'
+            }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }

comparing_size/eval.py

@@ -0,0 +1,73 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['Rows']
+        colours_present = entry['Gold_output']
+        colours_present = [s.lower() for s in colours_present]
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            prediction = entry['Output']
+            prediction = [s.lower() for s in prediction]
+        except:
+            continue
+        # print(prediction , odd_one)
+        # Check if the prediction is correct
+        if colours_present == prediction:
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

count_coloured_circles/eval.py

@@ -0,0 +1,74 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['num_objects']
+        order = entry['red_circle']    
+        order = int(order)
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            predicted_order = entry['Output']
+            predicted_order = int(predicted_order)
+        except:
+            continue
+        
+
+        # Check if the prediction is correct
+        if predicted_order != None and predicted_order == order:
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to " + args.output)

counting_circles/eval.py

@@ -0,0 +1,71 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer_gpt4o.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval_gpt4o.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['num_objects']
+        
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            predicted_count = entry['Output']
+        except:
+            continue
+        
+        # Check if the prediction is correct
+        if predicted_count != None and int(num_objects) == int(predicted_count):
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

counting_circles/utils.py

@@ -0,0 +1,27 @@
+import re
+
+
+def output_from_text(text):
+    #extract the number in the last line of text
+    try:
+        lines = text.strip().split("\n")
+        lines = list(filter(None, lines))
+        pattern = r'^[^a-zA-Z0-9\s]+$'
+        lines = [s for s in lines if not re.fullmatch(pattern, s)]
+        answer = -1
+        answer = int(re.findall(r"\b\d+\b", lines[-1])[0])
+        if answer != -1:
+            return {
+                "OUTPUT": answer,
+                "ERROR": None
+            }
+        else:
+            return{
+                "OUTPUT": None,
+                "ERROR": 'Does not give correct format'
+            }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }

cross_and_knots/eval.py

@@ -0,0 +1,79 @@
+import json
+
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer_gpt4o.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval_gpt4o.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+
+    for entry in data:
+        grid_size = entry['n']
+        num_circles = entry['crosses']
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        #if grid_size not in category_accuracies:
+        #    category_accuracies[grid_size] = {'correct': 0  , 'total': 0}
+        
+        if num_circles not in category_accuracies:
+            category_accuracies[num_circles] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_circles]['total'] += 1
+        #category_accuracies['total'] += 1
+        # category_accuracies[(grid_size,num_circles)]['total'] += 1
+
+        if entry["ERROR"]:
+            continue
+
+        # Check if the output is correct
+        output = entry["Output"]
+
+        if output is None:
+            if len(entry["gold_output"]) == 0:
+                correct_counts += 1
+                category_accuracies[num_circles]['correct'] += 1
+        else:
+            if output in entry["gold_output"]:
+                correct_counts += 1
+                category_accuracies[num_circles]['correct'] += 1
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

cross_and_knots/utils.py

@@ -0,0 +1,99 @@
+import re
+import json
+import os
+
+def output_from_text(output_text):
+    try:
+        output_text = output_text.split('\n')
+        # print(output_text)
+        out_line = output_text[-1].strip()
+        #print(out_line)
+        if out_line == "None":
+            return {
+                "OUTPUT": None,
+                "ERROR": None
+            }
+        else:
+            try:
+                match = re.search(r'\((-?\d+)\s*,\s*(-?\d+)\)', out_line)
+                
+                if match:
+                    # Extract x and y values as integers
+                    #print(match.group(1))
+                    #print(match.group(2))
+                    x, y = map(int, match.groups())
+                    # print(x, y)
+                    return {
+                        "OUTPUT": (x, y),
+                        "ERROR": None
+                    }
+                else:
+                    out_line = output_text[-1].strip()
+                    match = re.search(r'\[(-?\d+),\s*(-?\d+)\]', out_line)
+    
+                    if match:
+                        # Extract x and y values as integers
+                        x, y = map(int, match.groups())
+                        # print(x, y)
+                        return {
+                            "OUTPUT": (x, y),
+                            "ERROR": None
+                        }
+                    else:
+                        return {
+                            "OUTPUT": None,
+                            "ERROR": "Output file should have a single tuple of integers"
+                        }
+            except Exception as e:
+                return {
+                    "OUTPUT": None,
+                    "ERROR": f"Unexpected error while parsing {str(e)}\n"
+                }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": f"Unexpected error while parsing {str(e)}\n"
+        }
+    
+    
+
+def gold_to_output(i):
+    gold_output = None
+    try:
+        #get directory of this file
+        dir_of_file = os.path.dirname(os.path.realpath(__file__))
+        #open the data file
+        with open(dir_of_file + "\data.json") as f:
+            data = json.load(f)
+        row = data[i]
+        gold_output = row['gold_output']    
+        x = gold_output[-1][0]
+        y = gold_output[-1][1]
+        output_prompt = f"({x}, {y})"
+
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }
+    
+    return {
+        "OUTPUT": output_prompt,
+        "ERROR": None
+    }
+
+
+# # Test the function
+# with open("./answer_few_shot.json", "r") as f:
+#     data = json.load(f)
+#     # print(data[1])
+#     for i in data:
+#         output_text = i["gpt_response"]
+#         i["Output"] = output_from_text(output_text)["OUTPUT"]
+#         i["ERROR"] = output_from_text(output_text)["ERROR"]
+#         #remove OUTPUT key
+#         # i.pop("OUTPUT")
+    
+#     with open("./answer_few_shot.json", "w") as f:
+#         json.dump(data, f, indent=4)
+#         print("Output saved to answer.json")

identifying_shapes/eval.py

@@ -0,0 +1,73 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['Rows']
+        colours_present = entry['Gold_output']
+        colours_present = [s.lower() for s in colours_present]
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            prediction = entry['Output']
+            prediction = [s.lower() for s in prediction]
+        except:
+            continue
+        # print(prediction , odd_one)
+        # Check if the prediction is correct
+        if colours_present == prediction:
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

identifying_shapes/utils.py

@@ -0,0 +1,53 @@
+import json
+import os
+import re
+
+def output_from_text(output_text):
+    try:
+        
+        lines = output_text.strip().split("\n")
+        lines = list(filter(None, lines))
+        last_line = list(filter(None, lines[-1].split(" ")))
+
+        answer = []
+        for x in last_line:
+            word = re.sub(r'[^a-zA-Z]', '', x.lower())
+            if word != 'answer':
+                answer.append(word)
+        if answer != []:
+            return {
+                "OUTPUT": answer,
+                "ERROR": None
+            }
+        else:
+            return{
+                "OUTPUT": None,
+                "ERROR": 'Does not give answer in correct format'
+            }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }
+
+def gold_to_output(i):
+    gold_output = None
+    try:
+         #get directory of this file
+        dir_of_file = os.path.dirname(os.path.realpath(__file__))
+        #open the data file
+        with open(dir_of_file + "\data.json") as f:
+            data = json.load(f)
+        row = data[i]
+        gold_output = row['num_objects']
+        output_prompt = "COUNT:" + str(gold_output)
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }
+    
+    return {
+        "OUTPUT": output_prompt,
+        "ERROR": None
+    }

layered_colours/eval.py

@@ -0,0 +1,75 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['num_layers']
+        order = entry['colors']    
+        order = [s.lower() for s in order]
+        #order = order[::-1]
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            predicted_order = entry['Output']
+            predicted_order = [s.lower() for s in predicted_order]
+        except:
+            continue
+        
+
+        # Check if the prediction is correct
+        if predicted_order == order:
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

layered_colours/utils.py

@@ -0,0 +1,51 @@
+import re
+
+# def output_from_text(output_text):
+#     try:
+#         try:
+#             lline = output_text.split("\n")[-1].strip()
+#             shape = lline.split(":")[-1].strip()
+#             word1 = lline.split(":")[0].strip().lower()
+#             if word1 != "answer":
+#                 raise Exception("Invalid output")
+#             return {"OUTPUT": shape.lower(), "ERROR": None}
+#         except:
+#             try:
+#                 lline = output_text.split("\n")[-2]
+#                 shape = lline.split(":")[-1].strip()
+#                 if shape.lower() not in ["circle", "rectangle", "triangle"]:
+#                     raise Exception("Invalid output")
+#                 return {"OUTPUT": shape.lower(), "ERROR": None}
+#             except:
+#                 return {"OUTPUT": None, "ERROR": "Invalid output"}
+    
+#     except Exception as e:
+#         return {"OUTPUT": None, "ERROR": str(e)}
+
+
+def output_from_text(output_text):
+
+    try:
+        lines = output_text.strip().split("\n")
+        lines = list(filter(None, lines))
+        last_line = list(filter(None, lines[-1].split(" ")))
+        colours = ['black', 'gray', 'brown', 'maroon', 'red', 'coral', 'tan', 'orange', 'ivory', 'goldenrod', 'yellow', 'green', 'olive', 'turquoise', 'skyblue', 'blue', 'lavender', 'purple', 'pink', 'fuchsia']
+
+        #last_line = [x.lower() for x in last_line]
+        answer = []
+        for x in last_line:
+            word = re.sub(r'[^a-zA-Z]', '', x.lower())
+            if word in colours:
+                answer.append(word.lower())
+
+        return {
+                "OUTPUT": answer,
+                "ERROR": None
+        }
+
+    except Exception as e:
+
+        return {
+            "OUTPUT": None,
+            "ERROR": f"Unexpected error while parsing {str(e)}\n"
+        }

layered_shapes/utils.py

@@ -0,0 +1,53 @@
+# def output_from_text(output_text):
+#     try:
+#         try:
+#             lline = output_text.split("\n")[-1].strip()
+#             shape = lline.split(":")[-1].strip()
+#             word1 = lline.split(":")[0].strip().lower()
+#             if word1 != "answer":
+#                 raise Exception("Invalid output")
+#             return {"OUTPUT": shape.lower(), "ERROR": None}
+#         except:
+#             try:
+#                 lline = output_text.split("\n")[-2]
+#                 shape = lline.split(":")[-1].strip()
+#                 if shape.lower() not in ["circle", "rectangle", "triangle"]:
+#                     raise Exception("Invalid output")
+#                 return {"OUTPUT": shape.lower(), "ERROR": None}
+#             except:
+#                 return {"OUTPUT": None, "ERROR": "Invalid output"}
+    
+#     except Exception as e:
+#         return {"OUTPUT": None, "ERROR": str(e)}
+
+
+def output_from_text(output_text):
+
+    try:
+        output_text = output_text.split(':')
+        # print(output_text)
+        # if len(output_text) < 2:
+        out_line = output_text[-1].strip()
+        # else:
+        #     out_line = output_text[-2].strip()
+            
+        try:
+            path = [word.strip() for word in out_line.split(",")]
+
+            # if len(path) >= 2:
+            return {
+                "OUTPUT": path,
+                "ERROR": None
+            }
+           
+        except Exception as e:
+            return {
+                "OUTPUT": None,
+                "ERROR": f"Unexpected error while parsing {str(e)}\n"
+            }
+    except Exception as e:
+
+        return {
+            "OUTPUT": None,
+            "ERROR": f"Unexpected error while parsing {str(e)}\n"
+        }

list_shapes/eval.py

@@ -0,0 +1,77 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['num_objects']
+        order = entry['list_shapes']    
+        order = [s.lower() for s in order]
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            predicted_order = entry['Output']
+            predicted_order = [s.lower() for s in predicted_order]
+            """for i in range(len(predicted_order)):
+                if predicted_order[i] == "rectangle" or predicted_order[i] == "diamond":
+                    predicted_order[i] = "square"""
+        except:
+            continue
+        
+
+        # Check if the prediction is correct
+        if predicted_order == order:
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

list_shapes/utils.py

@@ -0,0 +1,34 @@
+import re
+import matplotlib.colors as mcolors
+
+
+def output_from_text(text):
+    #extract the number in the last line of text
+    try:
+        lines = text.strip().split("\n")
+        lines = list(filter(None, lines))
+        last_line = list(filter(None, lines[-1].split(" ")))
+        shapes = ['circle', 'triangle', 'rectangle', 'pentagon', 'square']
+        #colours = sorted(mcolors.CSS4_COLORS, key=lambda c: tuple(mcolors.rgb_to_hsv(mcolors.to_rgb(c))))
+        #last_line = [x.lower() for x in last_line]
+        answer = set()
+        for x in last_line:
+            word = re.sub(r'[^a-zA-Z]', '', x.lower())
+            if word in shapes:
+                answer.add(word.lower())
+
+        if answer:
+            return {
+                "OUTPUT": sorted(list(answer)),
+                "ERROR": None
+            }
+        else:
+            return{
+                "OUTPUT": None,
+                "ERROR": 'Does not give correct format'
+            }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }

locate_circles_colour/eval.py

@@ -0,0 +1,72 @@
+import json
+
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer_gpt4o.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval_gpt4o.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        grid_size = entry['rows']
+        n_circles = entry['n_circles']
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        
+        if n_circles not in category_accuracies:
+            category_accuracies[n_circles] = {'correct': 0, 'total': 0}
+
+        category_accuracies[n_circles]['total'] += 1
+        # category_accuracies[(grid_size,n_circles)]['total'] += 1
+
+        if entry["ERROR"]:
+            continue
+
+        # Check if the output is correct
+        output = entry["Output"]
+        gold_output = entry["gold_output"]
+
+        #check if elements in output are in gold_output
+        if sorted(output) == sorted(gold_output) :
+            correct_counts += 1
+            category_accuracies[n_circles]['correct'] += 1
+            # category_accuracies[(grid_size,n_circles)]['correct'] += 1
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

locate_circles_colour/utils.py

@@ -0,0 +1,55 @@
+def output_from_text(output_text):
+    try:
+        try:
+            # print(1)
+            lline = output_text.split("\n")[-1].strip()
+            # print(lline)
+            lline = lline.split(":")[-1].strip()
+            # print(lline)
+            coordinates = lline.split(" ")
+            # print(coordinates)
+            #the list of coordinates now has in form (r,c) where r is the row and c is the column
+            # i want to extract r and c and store them in a list
+            coord_list = []
+            for i in coordinates:
+                i = i.strip("()")
+                i = i.split(",")
+                coord_list.append((int(i[0]), int(i[1]))
+            )
+            # if coord_list == ["```"]:
+            #     raise Exception("Invalid output")
+            return {"OUTPUT": coord_list, "ERROR": None}
+        except:
+            try:
+                lline = output_text.split("\n")[-2]
+                coordinates = lline.split(" ")
+                #the list of coordinates now has in form (r,c) where r is the row and c is the column
+                # i want to extract r and c and store them in a list
+                coord_list = []
+                for i in coordinates:
+                    i = i.strip("()")
+                    i = i.split(",")
+                    coord_list.append((int(i[0]), int(i[1]))
+                )
+                return {"OUTPUT": coord_list, "ERROR": None}
+            except:
+                return {"OUTPUT": None, "ERROR": "Invalid output"}
+    
+    except Exception as e:
+        return {"OUTPUT": None, "ERROR": str(e)}
+
+ 
+# import json
+# with open("./answer.json", "r") as f:
+#     data = json.load(f)
+#     # print(data[1])
+#     for i in data:
+#         output_text = i["gpt_response"]
+#         i["Output"] = output_from_text(output_text)["OUTPUT"]
+#         i["ERROR"] = output_from_text(output_text)["ERROR"]
+#         #remove OUTPUT key
+#         # i.pop("OUTPUT")
+    
+#     with open("./answer.json", "w") as f:
+#         json.dump(data, f, indent=4)
+#         print("Output saved to answer.json")

locate_circles_shape/eval.py

@@ -0,0 +1,72 @@
+import json
+
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer_gpt4o.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval_gpt4o.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        grid_size = entry['rows']
+        n_circles = entry['n_circles']
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        
+        if n_circles not in category_accuracies:
+            category_accuracies[n_circles] = {'correct': 0, 'total': 0}
+
+        category_accuracies[n_circles]['total'] += 1
+        # category_accuracies[(grid_size,n_circles)]['total'] += 1
+
+        if entry["ERROR"]:
+            continue
+
+        # Check if the output is correct
+        output = entry["Output"]
+        gold_output = entry["gold_output"]
+
+        #check if elements in output are in gold_output
+        if sorted(output) == sorted(gold_output) :
+            correct_counts += 1
+            category_accuracies[n_circles]['correct'] += 1
+            # category_accuracies[(grid_size,n_circles)]['correct'] += 1
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

locate_circles_shape/utils.py

@@ -0,0 +1,55 @@
+def output_from_text(output_text):
+    try:
+        try:
+            # print(1)
+            lline = output_text.split("\n")[-1].strip()
+            # print(lline)
+            lline = lline.split(":")[-1].strip()
+            # print(lline)
+            coordinates = lline.split(" ")
+            # print(coordinates)
+            #the list of coordinates now has in form (r,c) where r is the row and c is the column
+            # i want to extract r and c and store them in a list
+            coord_list = []
+            for i in coordinates:
+                i = i.strip("()")
+                i = i.split(",")
+                coord_list.append((int(i[0]), int(i[1]))
+            )
+            # if coord_list == ["```"]:
+            #     raise Exception("Invalid output")
+            return {"OUTPUT": coord_list, "ERROR": None}
+        except:
+            try:
+                lline = output_text.split("\n")[-2]
+                coordinates = lline.split(" ")
+                #the list of coordinates now has in form (r,c) where r is the row and c is the column
+                # i want to extract r and c and store them in a list
+                coord_list = []
+                for i in coordinates:
+                    i = i.strip("()")
+                    i = i.split(",")
+                    coord_list.append((int(i[0]), int(i[1]))
+                )
+                return {"OUTPUT": coord_list, "ERROR": None}
+            except:
+                return {"OUTPUT": None, "ERROR": "Invalid output"}
+    
+    except Exception as e:
+        return {"OUTPUT": None, "ERROR": str(e)}
+
+ 
+# import json
+# with open("./answer.json", "r") as f:
+#     data = json.load(f)
+#     # print(data[1])
+#     for i in data:
+#         output_text = i["gpt_response"]
+#         i["Output"] = output_from_text(output_text)["OUTPUT"]
+#         i["ERROR"] = output_from_text(output_text)["ERROR"]
+#         #remove OUTPUT key
+#         # i.pop("OUTPUT")
+    
+#     with open("./answer.json", "w") as f:
+#         json.dump(data, f, indent=4)
+#         print("Output saved to answer.json")

match_outline/eval.py

@@ -0,0 +1,74 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['Rows']
+        order = entry['Gold_output']    
+        order = int(order)
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            predicted_order = entry['Output']
+            predicted_order = int(predicted_order)
+        except:
+            continue
+        
+
+        # Check if the prediction is correct
+        if predicted_order == order:
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

match_outline/utils.py

@@ -0,0 +1,28 @@
+import re
+
+
+def output_from_text(text):
+    #extract the number in the last line of text
+    try:
+        lines = text.strip().split("\n")
+        lines = list(filter(None, lines))
+        pattern = r'^[^a-zA-Z0-9\s]+$'
+        lines = [s for s in lines if not re.fullmatch(pattern, s)]
+        answer = -1
+        answer = int(re.findall(r"\b\d+\b", lines[-1])[0])
+
+        if answer != -1:
+            return {
+                "OUTPUT": answer,
+                "ERROR": None
+            }
+        else:
+            return{
+                "OUTPUT": None,
+                "ERROR": 'Does not give correct format'
+            }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }

maze_solving/eval.py

@@ -0,0 +1,70 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer_gpt4o.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval_gpt4o.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_rows = entry['Rows']
+        num_columns = entry['Columns']
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        # category_key = f"{num_rows}"
+        category_key = len(entry['path'])-2
+        if category_key not in category_accuracies:
+            category_accuracies[category_key] = {'correct': 0, 'total': 0}
+
+        category_accuracies[category_key]['total'] += 1
+
+        try:
+            predicted_output = entry['Output']
+        except:
+            continue
+
+        if predicted_output == entry['path']:
+            correct_counts += 1
+            category_accuracies[category_key]['correct'] += 1
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print(f"Evaluation results saved to {args.output}.")

mirror_image/eval.py

@@ -0,0 +1,71 @@
+import json
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_objects = entry['num_objects']
+        water_image = entry['mirror_image']
+
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_objects not in category_accuracies:
+            category_accuracies[num_objects] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_objects]['total'] += 1
+
+        try:
+            prediction = entry['Output']
+        except:
+            continue
+        # print(prediction , odd_one)
+        # Check if the prediction is correct
+        if prediction != None and int(water_image) == int(prediction):
+            correct_counts += 1
+            category_accuracies[num_objects]['correct'] += 1
+        
+        
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print("Evaluation results saved to eval.json.")

sort_lines/eval.py

@@ -0,0 +1,67 @@
+import json
+
+import argparse
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Evaluation script for comparing_size task")
+    parser.add_argument(
+        '--answer', '-a',
+        type=str,
+        default='answer_gpt4o.json',
+        help='Path to the answer JSON file (default: answer.json)'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        type=str,
+        default='eval_gpt4o.json',
+        help='Path to the output JSON file (default: eval.json)'
+    )
+    args = parser.parse_args()
+    # Assuming your JSON data is stored in a file called 'results.json'
+    with open(args.answer, 'r') as f:
+        data = json.load(f)
+
+    # Initialize variables to calculate accuracies
+    correct_counts = 0
+    total_counts = 0
+    category_accuracies = {}
+
+    # Iterate through the JSON data
+    for entry in data:
+        num_rows = entry['Lines']
+        total_counts += 1
+
+        # Calculate per-category accuracy
+        if num_rows not in category_accuracies:
+            category_accuracies[num_rows] = {'correct': 0, 'total': 0}
+
+        category_accuracies[num_rows]['total'] += 1
+
+        try:
+            predicted_output = entry['Output']
+        except:
+            continue
+
+        if predicted_output == entry['Gold_output']:
+            correct_counts += 1
+            category_accuracies[num_rows]['correct'] += 1
+
+    # Calculate overall accuracy
+    overall_accuracy = correct_counts / total_counts * 100
+
+    # Calculate accuracy for each category
+    category_accuracy_percentages = {
+        k: (v['correct'] / v['total'] * 100) for k, v in category_accuracies.items()
+    }
+
+    # Prepare results for saving
+    eval_results = {
+        "Overall Accuracy": overall_accuracy,
+        "Category-wise Accuracy": category_accuracy_percentages
+    }
+
+    # Save results to eval.json
+    with open(args.output, 'w') as eval_file:
+        json.dump(eval_results, eval_file, indent=4)
+
+    print(f"Evaluation results saved to {args.output}.")

sort_lines/utils.py

@@ -0,0 +1,18 @@
+def output_from_text(text):
+    """
+    Parse the text to extract the number of objects and the path.
+    Splits the text by commas and removes leading and trailing whitespace from each element.
+    """
+    try:
+        lines = text.strip().split("\n")
+        path = [int(item.strip()) for item in lines[-1].split(" ")]
+        return {
+            "OUTPUT": path,
+            "ERROR": None
+        }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }
+

vanishing_objects/utils.py

@@ -0,0 +1,88 @@
+import re
+
+
+def output_from_text(text):
+    #extract the number in the last line of text
+    try:
+        lines = text.strip().split("\n")
+        lines = list(filter(None, lines))
+        pattern = r'^[^a-zA-Z0-9\s]+$'
+        lines = [s for s in lines if not re.fullmatch(pattern, s)]
+        diff = -1
+        diff = int(re.findall(r"\b\d+\b", lines[-1])[0])
+
+        if diff != -1:
+            return {
+                "OUTPUT": diff,
+                "ERROR": None
+            }
+        else:
+            return{
+                "OUTPUT": None,
+                "ERROR": 'Does not give correct format'
+            }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }
+
+"""import json
+import os
+
+def output_from_text(output_text):
+    try:
+        
+        output_text = output_text.split('\n')
+        # print(output_text)
+        out_words = output_text[-1].split(' ')
+        if len(out_words) != 1:
+            return {
+                "OUTPUT": None,
+                "ERROR": "Output file should have only 1 word"
+            }
+        else:
+            count = out_words[0].split(':')
+            if (count[0] == 'COUNT'):
+                return {
+                    "OUTPUT": {
+                        "vanished": int(count[1])
+                    },
+                    "ERROR": None
+                }
+            else:
+                return {
+                    "OUTPUT": None,
+                    "ERROR": "Output format is not correct"
+                }
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": f"Unexpected error while parsing {str(e)}\n"
+        }
+
+def gold_to_output(i):
+    gold_output = None
+    try:
+        #get directory of this file
+        dir_of_file = os.path.dirname(os.path.realpath(__file__))
+        #open the data file
+        with open(dir_of_file + "\data.json") as f:
+            data = json.load(f)
+        row = data[i]
+        circles = row['circles']
+        triangles = row['triangles']
+        squares = row['squares']
+        vanished = row['vanished']
+        output_prompt = f"CIRCLES:{circles} TRIANGLES:{triangles} SQUARES:{squares} VANISHED:{vanished}"
+
+    except Exception as e:
+        return {
+            "OUTPUT": None,
+            "ERROR": str(e)
+        }
+    
+    return {
+        "OUTPUT": output_prompt,
+        "ERROR": None
+    }"""