Update README.md

README.md

@@ -74,7 +74,402 @@ Key Features:
   - Apple CarPlay: 13
   - Google Android Auto: 7
 
+## Usage
+Corresponding model [ELAM](https://huggingface.co/sparks-solutions/ELAM-7B) is available on Hugging Face as well.
 
+<details>
+  <summary>Setup Environment for ELAM-7B</summary>
+  
+```
+conda create -n elam python=3.10 -y
+conda activate elam
+pip install datasets==3.5.0 einops==0.8.1 torchvision==0.20.1 accelerate==1.6.0
+pip install transformers==4.48.2
+```
+</details>
+
+<details>
+  <summary>Dataloading and Inference with ELAM-7B</summary>
+  
+```python
+# Run inference on AutomotiveUI-4k dataset on local GPU
+# Outputs will be written in a JSONL file
+import json
+import os
+import time
+
+import torch
+from datasets import Dataset, load_dataset
+from tqdm import tqdm
+from transformers import AutoModelForCausalLM, AutoProcessor, GenerationConfig
+
+
+def preprocess_prompt_elam(user_request: str, label_class: str) -> str:
+    """Apply ELAM prompt template depending on class."""
+    if label_class == "Expected Result":
+        return f"Evaluate this statement about the image:\n'{user_request}'\nThink step by step, conclude whether the evaluation is 'PASSED' or 'FAILED' and point to the UI element that corresponds to this evaluation."
+    elif label_class == "Test Action":
+        return f"Identify and point to the UI element that corresponds to this test action:\n{user_request}"
+    else:
+        raise ValueError()
+
+
+def append_to_jsonl_file(data: dict, target_path: str) -> None:
+    assert str(target_path).endswith(".jsonl")
+    with open(target_path, "a", encoding="utf-8") as file:
+        file.write(f"{json.dumps(data, ensure_ascii=False)}\n")
+
+
+def run_inference(dataset: Dataset, model: AutoModelForCausalLM, processor: AutoProcessor):
+    # Define output dir and file
+    timestamp = time.strftime("%Y%m%d-%H%M%S")
+    DEBUG_DIR = os.path.join("eval_output", timestamp)
+    model_outputs_path = os.path.join(DEBUG_DIR, f"model_outputs.jsonl")
+
+    print(f"Writing data to: {model_outputs_path}")
+    for sample_id, sample in enumerate(tqdm(dataset, desc="Processing")):
+        image = sample["image"]
+
+        gt_box = sample["box"][0]
+        label_class = sample["class"]
+
+        # read gt box
+        utterance = None
+        gt_status = None
+        if "Expected Result" == label_class:
+            utterance = sample["expectation"]
+            gt_status = sample["conclusion"].upper()
+
+        elif "Test Action" == label_class:
+            utterance = sample["test_action"]
+        else:
+            raise ValueError(f"Did not find valid utterance for image #{sample_id}.")
+        assert utterance
+
+        # Apply prompt template
+        rephrased_utterance = preprocess_prompt_elam(utterance, label_class)
+
+        # Process the image and text
+        inputs = processor.process(
+            images=[image],
+            text=rephrased_utterance,
+        )
+
+        # Move inputs to the correct device and make a batch of size 1, cast to bfloat16
+        inputs_bfloat16 = {}
+        for k, v in inputs.items():
+            if v.dtype == torch.float32:
+                inputs_bfloat16[k] = v.to(model.device).to(torch.bfloat16).unsqueeze(0)
+            else:
+                inputs_bfloat16[k] = v.to(model.device).unsqueeze(0)
+
+        inputs = inputs_bfloat16  # Replace original inputs with the correctly typed inputs
+
+        # Generate output
+        output = model.generate_from_batch(
+            inputs, GenerationConfig(max_new_tokens=2048, stop_strings="<|endoftext|>"), tokenizer=processor.tokenizer
+        )
+
+        # Only get generated tokens; decode them to text
+        generated_tokens = output[0, inputs["input_ids"].size(1) :]
+        response = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True)
+
+        # write current image with current label
+        os.makedirs(DEBUG_DIR, exist_ok=True)
+
+        # append line to jsonl
+        model_output_line = {
+            "sample_id": sample_id,
+            "input": rephrased_utterance,
+            "output": response,
+            "image_size": image.size,
+            "gt_class": label_class,
+            "gt_box": gt_box,
+            "gt_status": gt_status,
+            "language": sample["language"],
+        }
+        append_to_jsonl_file(model_output_line, target_path=model_outputs_path)
+
+
+if __name__ == "__main__":
+    # Set dataset
+    dataset = load_dataset("sparks-solutions/AutomotiveUI-Bench-4K")["test"]
+
+    # Load the processor
+    model_name = "sparks-solutions/ELAM-7B"
+    processor = AutoProcessor.from_pretrained(
+        model_name, trust_remote_code=True, torch_dtype="bfloat16", device_map="auto"
+    )
+
+    # Load the model
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name, trust_remote_code=True, torch_dtype="bfloat16", device_map="auto"
+    )
+    run_inference(dataset=dataset, processor=processor, model=model)
+
+```
+</details>
+
+
+<details>
+  <summary>Parsing results and calculating metrics</summary>
+  
+```python
+import argparse
+import json
+import re
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+
+
+def read_jsonl_file(path: str) -> list:
+    assert str(path).endswith(".jsonl")
+    data_list = []
+    with open(path, "r", encoding="utf-8") as file:
+        for line in file:
+            data = json.loads(line)
+            data_list.append(data)
+    return data_list
+
+
+def write_json_file(data: dict | list, path: str) -> None:
+    assert str(path).endswith(".json")
+    with open(path, "w", encoding="utf-8") as outfile:
+        json.dump(data, outfile, ensure_ascii=False, indent=4)
+
+
+def postprocess_response_elam(response: str) -> Tuple[float, float]:
+    """Parse Molmo-style point coordinates from string."""
+    pattern = r'<point x="(?P<x>\d+\.\d+)" y="(?P<y>\d+\.\d+)"'
+    match = re.search(pattern, response)
+    if match:
+        x_coord_raw = float(match.group("x"))
+        y_coord_raw = float(match.group("y"))
+        x_coord = x_coord_raw / 100
+        y_coord = y_coord_raw / 100
+        return [x_coord, y_coord]
+    else:
+        return [-1, -1]
+
+
+def pred_center_in_gt(predicted_boxes, ground_truth_boxes):
+    """Calculate the percentage of predictions where the predicted center is in the ground truth box and return the indices where it is not.
+
+    Args:
+        predicted_boxes (np.ndarray): shape (n, 4) of top-left bottom-right boxes or predicted points
+        ground_truth_boxes (np.ndarray): shape (n, 4) of top-left bottom-right boxes
+
+    Returns:
+        float: percentage of predictions where the predicted center is in the ground truth box
+        list: indices of predictions where the center is not in the ground truth box
+    """
+    if ground_truth_boxes.size == 0:  # Check for empty numpy array just to be explicit
+        return -1
+    if predicted_boxes.shape[1] == 2:
+        predicted_centers = predicted_boxes
+    else:
+        # Calculate the centers of the bounding boxes
+        predicted_centers = (predicted_boxes[:, :2] + predicted_boxes[:, 2:]) / 2
+
+    # Check if predicted centers are within ground truth boxes
+    within_gt = (
+        (predicted_centers[:, 0] >= ground_truth_boxes[:, 0])
+        & (predicted_centers[:, 0] <= ground_truth_boxes[:, 2])
+        & (predicted_centers[:, 1] >= ground_truth_boxes[:, 1])
+        & (predicted_centers[:, 1] <= ground_truth_boxes[:, 3])
+    )
+
+    return within_gt
+
+
+def to_mean_percent(metrics: list | np.ndarray) -> float:
+    """Calculate mean of array and multiply by 100."""
+    return np.mean(metrics) * 100
+
+
+def calculate_alignment_numpy(array1, array2):
+    """Returns boolean array where values are equal"""
+
+    if array1.size == 0:  # Check for empty numpy array just to be explicit
+        return [], [], []
+
+    # Overall Accuracy
+    overall_hits = array1 == array2
+
+    # True Ground Truth Accuracy
+    true_ground_truth_indices = array2 == True  # Boolean mask for True ground truth
+    true_ground_truth_predictions = array1[true_ground_truth_indices]
+    true_ground_truth_actuals = array2[true_ground_truth_indices]
+
+    true_gt_hits = true_ground_truth_predictions == true_ground_truth_actuals
+
+    # False Ground Truth Accuracy
+    false_ground_truth_indices = array2 == False  # Boolean mask for False ground truth
+    false_ground_truth_predictions = array1[false_ground_truth_indices]
+    false_ground_truth_actuals = array2[false_ground_truth_indices]
+
+    false_gt_hits = false_ground_truth_predictions == false_ground_truth_actuals
+    return overall_hits, true_gt_hits, false_gt_hits
+
+
+def clip_non_minus_one(arr):
+    """Clips values in a NumPy array to [0, 1] but leaves -1 values unchanged."""
+    # Create a boolean mask for values NOT equal to -1
+    mask = arr != -1
+
+    # Create a copy of the array to avoid modifying the original in-place
+    clipped_arr = np.copy(arr)
+
+    # Apply clipping ONLY to the elements where the mask is True
+    clipped_arr[mask] = np.clip(clipped_arr[mask], 0, 1)
+
+    return clipped_arr
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run model inference and save outputs.")
+    parser.add_argument(
+        "-m", "--model_output_path", type=str, help="Path to json that contains model outputs from eval.", required=True
+    )
+
+    args = parser.parse_args()
+
+    EVAL_PATH = args.model_output_path
+    eval_jsonl_data = read_jsonl_file(EVAL_PATH)
+
+    ta_pred_bboxes, ta_gt_bboxes = [], []
+    er_pred_bboxes, er_gt_bboxes = [], []
+    er_pred_conclusion, er_gt_conclusion = [], []
+    ta_out_images, er_out_images = [], []
+    failed_pred_responses = []
+
+    er_en_ids = []
+    ta_en_ids = []
+    ta_de_ids = []
+    er_de_ids = []
+
+    for line in eval_jsonl_data:
+        # Read data from line
+        image_width, image_height = line["image_size"]
+        gt_box = line["gt_box"]
+        lang = line["language"]
+        response_raw = line["output"]
+
+        if "Test Action" == line["gt_class"]:
+            # Parse point/box from response and clip to image
+            parsed_response = postprocess_response_elam(response_raw)
+            if parsed_response[0] == -1:
+                failed_pred_responses.append({"sample_id": line["sample_id"], "response": response_raw})
+
+            parsed_response = np.array(parsed_response)
+            parsed_response = clip_non_minus_one(parsed_response).tolist()
+
+            # Append results
+            ta_gt_bboxes.append(gt_box)
+            ta_pred_bboxes.append(parsed_response)
+            if lang == "DE":
+                ta_de_ids.append(len(ta_pred_bboxes) - 1)  # append id
+            elif lang == "EN":
+                ta_en_ids.append(len(ta_pred_bboxes) - 1)
+
+        elif "Expected Result" in line["gt_class"]:
+            er_gt_bboxes.append(gt_box)
+
+            # Parse point/box from response and clip to image
+            parsed_response = postprocess_response_elam(response_raw)
+            if parsed_response[0] == -1:
+                failed_pred_responses.append({"sample_id": line["sample_id"], "response": response_raw})
+            parsed_response = np.array(parsed_response)
+            parsed_response = clip_non_minus_one(parsed_response).tolist()
+            er_pred_bboxes.append(parsed_response)
+
+            # Read evaluation conclusion
+            gt_conclusion = line["gt_status"].upper()
+            gt_conclusion = True if gt_conclusion == "PASSED" else False
+
+            pred_conclusion = None
+            if "FAILED" in response_raw or "is not met" in response_raw:
+                pred_conclusion = False
+            elif "PASSED" in response_raw or "is met" in response_raw:
+                pred_conclusion = True
+            if pred_conclusion is None:
+                # Make prediction wrong if it couldn't be parsed
+                pred_conclusion = not gt_conclusion
+
+            er_gt_conclusion.append(gt_conclusion)
+            er_pred_conclusion.append(pred_conclusion)
+
+            if lang == "DE":
+                er_de_ids.append(len(er_pred_bboxes) - 1)
+            elif lang == "EN":
+                er_en_ids.append(len(er_pred_bboxes) - 1)
+
+    ta_pred_bboxes = np.array(ta_pred_bboxes)
+    ta_gt_bboxes = np.array(ta_gt_bboxes)
+    er_pred_bboxes = np.array(er_pred_bboxes)
+    er_gt_bboxes = np.array(er_gt_bboxes)
+    er_pred_conclusion = np.array(er_pred_conclusion)
+    er_gt_conclusion = np.array(er_gt_conclusion)
+    print(f"{'Test action (pred/gt):':<{36}}{ta_pred_bboxes.shape}, {ta_gt_bboxes.shape}")
+    print(f"{'Expected results (pred/gt):':<{36}}{er_pred_bboxes.shape}, {er_gt_bboxes.shape}")
+
+    # Calculate metrics
+    ta_pred_hits = pred_center_in_gt(ta_pred_bboxes, ta_gt_bboxes)
+    score_ta = to_mean_percent(ta_pred_hits)
+
+    er_pred_hits = pred_center_in_gt(er_pred_bboxes, er_gt_bboxes)
+    score_er = to_mean_percent(er_pred_hits)
+
+    overall_hits, true_gt_hits, false_gt_hits = calculate_alignment_numpy(er_pred_conclusion, er_gt_conclusion)
+    score_conclusion = to_mean_percent(overall_hits)
+    score_conclusion_gt_true = to_mean_percent(true_gt_hits)
+    score_conclusion_gt_false = to_mean_percent(false_gt_hits)
+
+    # Calculate language-specific metrics for TA
+    score_ta_en = to_mean_percent(ta_pred_hits[ta_en_ids])
+    score_ta_de = to_mean_percent(ta_pred_hits[ta_de_ids])
+
+    # Calculate language-specific metrics for ER (bbox)
+    score_er_en = to_mean_percent(er_pred_hits[er_en_ids])
+    score_er_de = to_mean_percent(er_pred_hits[er_de_ids])
+
+    # Calculate language-specific metrics for ER (conclusion)
+    score_conclusion_en = to_mean_percent(overall_hits[er_en_ids])
+    score_conclusion_de = to_mean_percent(overall_hits[er_de_ids])
+
+    print(f"\n{'Test action visual grounding:':<{36}}{score_ta:.1f}")
+    print(f"{'Expected result visual grounding:':<{36}}{score_er:.1f}")
+    print(f"{'Expected result evaluation:':<{36}}{score_conclusion:.1f}\n")
+
+    eval_out_path = Path(EVAL_PATH).parent / "eval_results.json"
+
+    write_json_file(
+        {
+            "score_ta": score_ta,
+            "score_ta_de": score_ta_de,
+            "score_ta_en": score_ta_en,
+            "score_er": score_er,
+            "score_er_de": score_er_de,
+            "score_er_en": score_er_en,
+            "score_er_conclusion": score_conclusion,
+            "score_er_conclusion_de": score_conclusion_de,
+            "score_er_conclusion_en": score_conclusion_en,
+            "score_conclusion_gt_true": score_conclusion_gt_true,
+            "score_conclusion_gt_false": score_conclusion_gt_false,
+        },
+        path=eval_out_path,
+    )
+    print(f"Stored results at {eval_out_path}")
+
+    if failed_pred_responses:
+        failed_responses_out_path = Path(EVAL_PATH).parent / "failed_responses.json"
+        write_json_file(failed_pred_responses, failed_responses_out_path)
+        print(f"Stored non-parsable responses at {failed_responses_out_path}")
+
+```
+</details>
 
 
 ## Results
@@ -87,3 +482,7 @@ Key Features:
 | Molmo-7B-D-0924 | 71.3 | 71.4 | 66.9 |
 | LAM-270M (TinyClick) | 73.9 | 59.9 | - |
 | ELAM-7B (Molmo) | **87.6** | **77.5** | **78.2** |
+
+# Acknowledgements
+## Funding
+This work was supported by German BMBF within the scope of project "KI4BoardNet".