code of experiments

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+code/fine_tuning/data/OpenAI_subset_random_train_10250.jsonl filter=lfs diff=lfs merge=lfs -text
+code/fine_tuning/data/OpenAI_subset_random_val_2500.jsonl filter=lfs diff=lfs merge=lfs -text

code/fine_tuning/data/OpenAI_subset_random_train_10250.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05972b0f5806e8c2ca33d493e29e88a9fb2ea19d74fcfcfd14a6e55aae4b4625
+size 526903509

code/fine_tuning/data/OpenAI_subset_random_val_2500.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dedf18a2e2bbdd6e3fa5bd0c7f069d77ef64a7ad16aab0f959979b632f3a7ab
+size 128103663

code/fine_tuning/data/df_random_train_10250.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b864f791dcb98fc88ef73f83dc864bb3fadde5edde7b2c79d328e4ba90245996
+size 429083

code/fine_tuning/data/df_random_val_2500.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e359ed368c9c404649a41ccc4caa081c7a607dfd870f0f7409dad5ce83ee44b8
+size 160359

code/fine_tuning/fine_tuning_Gemma3_run_inference.py

@@ -0,0 +1,137 @@
+import gc
+import json
+import os
+import pandas as pd
+import time
+import torch
+
+from PIL import Image
+from datetime import datetime
+
+from transformers import AutoProcessor, AutoModelForImageTextToText
+
+import use_vlm_ft_gemma3
+
+def clear_memory():
+    # Delete variables if they exist in the current global scope
+    if "inputs" in globals():
+        del globals()["inputs"]
+    if "model" in globals():
+        del globals()["model"]
+    if "processor" in globals():
+        del globals()["processor"]
+    if "trainer" in globals():
+        del globals()["trainer"]
+    if "peft_model" in globals():
+        del globals()["peft_model"]
+    if "bnb_config" in globals():
+        del globals()["bnb_config"]
+    time.sleep(2)
+
+    # Garbage collection and clearing CUDA memory
+    gc.collect()
+    time.sleep(2)
+    torch.cuda.empty_cache()
+    # torch.cuda.synchronize()
+    time.sleep(2)
+    gc.collect()
+    time.sleep(2)
+
+    print(f"GPU allocated memory: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+    print(f"GPU reserved memory: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+
+
+if __name__ == "__main__":
+    clear_memory()
+
+    in_path_frame_images        = './.../rpp-765k_512'
+    in_file_data_entering_test  = './.../test.parquet'
+
+    in_model_name               = "google_gemma-3-4b-pt_local_FT"
+    in_name_results_output      = 'results'
+    out_path_results            = './.../output'
+    os.environ["USED_MODEL"]    = "google_gemma-3-4b_local_FT"
+
+    dict_log = {}
+    dict_log['model']           = in_model_name
+
+    print("in_model_name: " + str(in_model_name))
+
+    path_outputs = os.path.join(out_path_results, in_model_name)
+    os.makedirs(path_outputs, exist_ok=True)
+
+    df_result = pd.DataFrame(
+        columns=['label', 'filename', \
+        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+    df_result_cost = pd.DataFrame(
+        columns=['label', 'filename']
+    )
+
+    df_test = pd.read_parquet(in_file_data_entering_test, engine='pyarrow')
+    df_test.reset_index(drop=True, inplace=True)
+    
+    output_dir = "path-to-checkpoints-directory/google-gemma3-4b-pt/random-subset"
+    # Load Model with PEFT adapter
+    ft_model = AutoModelForImageTextToText.from_pretrained(
+        output_dir,
+        device_map="auto",
+        torch_dtype=torch.bfloat16,
+        attn_implementation="eager",
+    )
+    processor = AutoProcessor.from_pretrained(output_dir)
+
+    start_index = 0
+    output_file = f'{datetime.now().strftime("%Y%m%d_%H%M%S")}_{in_name_results_output}'
+
+    for index, row in df_test.iloc[start_index:].iterrows():
+        label       = str(row.label)
+        filename    = row.filename
+
+        dict_result = {}
+        dict_result['label']    = label
+        dict_result['filename'] = filename
+        dict_result_cost = {}
+        dict_result_cost['label']    = label
+        dict_result_cost['filename'] = filename
+            
+        ############################################
+        # PROMPT
+        ############################################
+        # IMAGE
+        image_path = os.path.join( in_path_frame_images, 'test', label, filename )
+        pil_image = Image.open(image_path)
+
+        # TASK
+        task = "Extract all targets."
+        dict_log['prompt_task'] = task
+
+        dict_log, dict_result, dict_result_cost = use_vlm_ft_gemma3.do_request(
+            ft_model,
+            processor,
+            pil_image, 
+            task, 
+            dict_log,
+            dict_result, 
+            dict_result_cost,
+        )
+        
+        df_result = pd.concat( [ df_result, pd.DataFrame.from_dict([dict_result]) ], ignore_index=True)
+        df_result_cost = pd.concat( [ df_result_cost, pd.DataFrame.from_dict([dict_result_cost]) ], ignore_index=True)
+
+        if index%100 == 0:
+            df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '_r.parquet'), index=False, engine='pyarrow')
+            df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '_r.parquet'), index=False, engine='pyarrow')
+            df_result = pd.DataFrame( columns=['label', 'filename', \
+                        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+            df_result_cost = pd.DataFrame(columns=['label', 'filename'])
+        
+    
+    df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '_r.parquet'), index=False, engine='pyarrow')
+    df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '_r.parquet'), index=False, engine='pyarrow')
+
+    #######################################################################
+    #######################################################################
+    
+    with open(os.path.join(path_outputs, in_name_results_output + '.json'), 'w') as json_file:
+        json.dump(dict_log, json_file)

code/fine_tuning/fine_tuning_Gemma3_save_model_adapter.ipynb

@@ -0,0 +1,40 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "cf52e279",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from peft import PeftModel\n",
+    "from transformers import AutoProcessor, AutoModelForImageTextToText\n",
+    "\n",
+    "\n",
+    "model_id = \"google/gemma-3-4b-pt\"\n",
+    "output_dir = \"path-to-checkpoints-directory/google-gemma3-4b-pt/random-subset\"\n",
+    "\n",
+    "# Load Model base model\n",
+    "model = AutoModelForImageTextToText.from_pretrained(model_id, low_cpu_mem_usage=True)\n",
+    "\n",
+    "# Merge LoRA and base model and save\n",
+    "peft_model = PeftModel.from_pretrained(model, output_dir)\n",
+    "merged_model = peft_model.merge_and_unload()\n",
+    "merged_model.save_pretrained(os.path.join(output_dir, \"merged_model\"), safe_serialization=True, max_shard_size=\"2GB\")\n",
+    "\n",
+    "processor = AutoProcessor.from_pretrained(output_dir)\n",
+    "processor.save_pretrained(os.path.join(output_dir, \"merged_model_processor\"))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

code/fine_tuning/fine_tuning_Gemma3_train_model.py

@@ -0,0 +1,328 @@
+import torch
+import gc
+import pickle
+import shutil
+import time
+# PEFT: Parameter-Efficient Fine-Tuning
+import peft
+import os
+# SFT: Supervised Fine-Tuning
+import trl
+import pandas as pd
+import pickle
+import huggingface_hub
+import getpass
+# logging
+import json
+import datetime
+import wandb
+
+from PIL import Image
+from tqdm import tqdm
+from datasets import load_dataset
+
+from transformers import AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig
+from torch.utils.data import Dataset
+
+
+def process_vision_info(messages: list[dict]) -> list[Image.Image]:
+    image_inputs = []
+    # Iterate through each conversation
+    for msg in messages:
+        # Get content (ensure it's a list)
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+
+        # Check each content element for images
+        for element in content:
+            if isinstance(element, dict) and (
+                "image" in element or element.get("type") == "image"
+            ):
+                # Get the image and convert to RGB
+                if "image" in element:
+                    image = element["image"]
+                else:
+                    image = element
+                image_inputs.append(image.convert("RGB"))
+    return image_inputs
+
+# Create a data collator to encode text and image pairs
+def collate_fn(examples):
+    texts = []
+    images = []
+    for example in examples:
+        image_inputs = process_vision_info(example["messages"])
+        text = processor.apply_chat_template(
+            example["messages"], add_generation_prompt=False, tokenize=False
+        )
+        texts.append(text.strip())
+        images.append(image_inputs)
+
+    # Tokenize the texts and process the images
+    batch = processor(text=texts, images=images, return_tensors="pt", padding=True)
+
+    # The labels are the input_ids, and we mask the padding tokens and image tokens in the loss computation
+    labels = batch["input_ids"].clone()
+
+    # Mask image tokens
+    image_token_id = [
+        processor.tokenizer.convert_tokens_to_ids(
+            processor.tokenizer.special_tokens_map["boi_token"]
+        )
+    ]
+    # Mask tokens for not being used in the loss computation
+    labels[labels == processor.tokenizer.pad_token_id] = -100
+    labels[labels == image_token_id] = -100
+    labels[labels == 262144] = -100
+
+    batch["labels"] = labels
+    return batch
+
+def clear_memory():
+    # Delete variables if they exist in the current global scope
+    if "inputs" in globals():
+        del globals()["inputs"]
+    if "model" in globals():
+        del globals()["model"]
+    if "processor" in globals():
+        del globals()["processor"]
+    if "trainer" in globals():
+        del globals()["trainer"]
+    if "peft_model" in globals():
+        del globals()["peft_model"]
+    if "bnb_config" in globals():
+        del globals()["bnb_config"]
+    time.sleep(2)
+
+    # Garbage collection and clearing CUDA memory
+    gc.collect()
+    time.sleep(2)
+    torch.cuda.empty_cache()
+    # torch.cuda.synchronize()
+    time.sleep(2)
+    gc.collect()
+    time.sleep(2)
+
+    print(f"GPU allocated memory: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+    print(f"GPU reserved memory: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+
+    import psutil
+    # Get memory details
+    mem = psutil.virtual_memory()
+    print(f"Total RAM: {mem.total / (1024 ** 3):.2f} GB")
+    print(f"Available RAM: {mem.available / (1024 ** 3):.2f} GB")
+    print(f"Used RAM: {mem.used / (1024 ** 3):.2f} GB")
+    print(f"Free RAM: {mem.free / (1024 ** 3):.2f} GB")
+    swap = psutil.swap_memory()
+    print(f"Total Swap: {swap.total / (1024 ** 3):.2f} GB")
+    print(f"Used Swap: {swap.used / (1024 ** 3):.2f} GB")
+    print(f"Free Swap: {swap.free / (1024 ** 3):.2f} GB")
+
+def format_data_ft_local(sample, system_message_training_data, human_message_training_data):  
+    return {
+        "messages": [
+            {
+                "role": "system",
+                "content": [{"type": "text", "text": system_message_training_data}],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image",
+                        "image": sample["image"],
+                    },
+                    {
+                        "type": "text",
+                        "text": human_message_training_data,
+                    },
+                ],
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": sample["label"]}],
+            },
+        ],
+    }
+
+def create_data_pkl(df, output_path):
+    system_message_training_data = "You are an assistant for question-answering tasks."
+
+    human_message_training_data  = "Do the user-provided task on the input image. \
+    The answer must be provided in JSON format. \
+    The task is: " + "Extract the features" + ".\
+    If there is no information of a target, return NaN."
+
+    dataset_id = "path-to-directory-of-training-dataset-from-HF"
+    train_dataset = load_dataset(dataset_id)
+
+    in_file_data_entering_train = 'path-to-file/train.parquet'
+    df_train = pd.read_parquet(in_file_data_entering_train, engine='pyarrow')
+
+    list_response_train = []
+    start_index = 0
+    for index, row in tqdm(df_train.iloc[start_index:].iterrows(), total=len(df_train)):
+        filename    = row.filename
+        
+        if filename not in df['filename'].values:
+            continue
+
+        sample = {}
+        
+        # IMAGE
+        sample["image"] = train_dataset['train'][index]['image']
+        
+        # RESPONSE EXAMPLES OF ASSISTANT
+        pp_data_per_image = ""
+        result = []
+        for idx, value in row.items():
+            if idx == 'label' or idx == 'filename':
+                continue
+            if pd.notnull(value):
+                if idx == 'product_weight':
+                    number = value.split(' ')[0]
+                    unit = value.split(' ')[1]
+                    result.append(f"weight_number: {number}")
+                    result.append(f"weight_unit: {unit}")
+                else: 
+                    result.append(f"{idx}: {value}")
+        pp_data_per_image = ", ".join(result)
+            
+        sample["label"] = "{" + pp_data_per_image + "}"
+
+        list_response_train.append(format_data_ft_local(sample, system_message_training_data, human_message_training_data))
+
+    with open(output_path, 'wb') as f:
+        pickle.dump(list_response_train, f)
+
+
+if __name__ == "__main__":
+    hf_token = getpass.getpass("Enter your Hugging Face token: ")
+    huggingface_hub.login(token=hf_token)
+
+    wandb_token = getpass.getpass("Enter your Weight and Bias token: ")
+    wandb.login(key=wandb_token)
+
+    clear_memory()
+
+    # create .pkl files from random dataset (run only once)
+    df_train = pd.read_parquet("path-to-file/df_random_train_10250.parquet", engine="pyarrow")
+    df_val = pd.read_parquet("path-to-file/df_random_val_2500.parquet", engine="pyarrow")
+    create_data_pkl(df=df_train, output_path='path-to-file/training_data_random_10250.pkl')
+    create_data_pkl(df=df_val, output_path='path-to-file/validation_data_random_2500.pkl')
+
+
+    # load .pkl files from random dataset
+    with open('path-to-file/training_data_random_10250.pkl', 'rb') as f:
+        train_dataset = pickle.load(f)
+    with open('path-to-file/validation_data_random_2500.pkl', 'rb') as f:
+        val_dataset = pickle.load(f)
+
+    # Hugging Face model id
+    model_id = "google/gemma-3-4b-pt"
+
+    # Check if GPU benefits from bfloat16
+    if torch.cuda.get_device_capability()[0] < 8:
+        raise ValueError("GPU does not support bfloat16, please use a GPU that supports bfloat16.")
+
+    # Define model init arguments
+    model_kwargs = dict(
+        attn_implementation="eager",
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        cache_dir="path-to-directory/tmp"
+    )
+
+    # BitsAndBytesConfig int-4 config
+    model_kwargs["quantization_config"] = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_use_double_quant=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=model_kwargs["torch_dtype"],
+        bnb_4bit_quant_storage=model_kwargs["torch_dtype"],
+    )
+
+    # Load model and tokenizer
+    model = AutoModelForImageTextToText.from_pretrained(model_id, **model_kwargs)
+    processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+
+    if torch.cuda.is_available():
+        for i in range(torch.cuda.device_count()):
+            print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
+    else:
+        print("No GPU available.")
+
+    folder_date = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    output_path = os.path.join("path-to-result-directory", "google_gemma-3-4b-pt", "subset-random", folder_date)
+    os.makedirs(output_path, exist_ok=True)
+
+    cache_path = "~/.cache"
+    if os.path.exists(cache_path):
+        shutil.rmtree(cache_path)
+
+    peft_config = peft.LoraConfig(
+        lora_alpha=16,
+        lora_dropout=0.05,
+        r=16,
+        bias="none",
+        target_modules="all-linear",
+        task_type="CAUSAL_LM",
+        modules_to_save=[
+            "lm_head",
+            "embed_tokens",
+        ],
+    )
+
+    args = trl.SFTConfig(
+        output_dir=output_path,                     # directory to save and repository id
+        num_train_epochs=3,                         # number of training epochs
+        per_device_train_batch_size=2,              # batch size per device during training
+        per_device_eval_batch_size=2,               # batch size per device during evaluation
+        gradient_accumulation_steps=4,              # number of steps before performing a backward/update pass
+        gradient_checkpointing=True,                # use gradient checkpointing to save memory
+        optim="adamw_torch_fused",                  # use fused adamw optimizer
+        logging_steps=5,                            # log every 5 steps
+        save_strategy="epoch",                      # save checkpoint every epoch
+        eval_strategy="epoch",                      # save checkpoint every epoch
+        learning_rate=2e-4,                         # learning rate, based on QLoRA paper
+        bf16=True,                                  # use bfloat16 precision
+        max_grad_norm=0.3,                          # max gradient norm based on QLoRA paper
+        warmup_ratio=0.03,                          # warmup ratio based on QLoRA paper
+        lr_scheduler_type="constant",               # use constant learning rate scheduler
+        push_to_hub=True,                           # push model to hub
+        report_to="wandb",
+        gradient_checkpointing_kwargs={
+            "use_reentrant": False
+        },
+        dataset_text_field="",                          # need a dummy field for collator
+        dataset_kwargs={"skip_prepare_dataset": True},  # important for collator
+    )
+    args.remove_unused_columns = False # important for collator
+    with open(os.path.join(output_path, "args.txt"), "w") as f:
+        f.write(json.dumps(args.to_dict(), indent=4))
+
+    trainer = trl.SFTTrainer(
+        model=model,
+        args=args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset,
+        peft_config=peft_config,
+        processing_class=processor,
+        data_collator=collate_fn,
+    )
+    
+    start_time = time.time()
+    trainer.train()
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+
+    with open(os.path.join(output_path, "elapsed_time.txt"), "w") as file:
+        file.write(f"Elapsed time: {elapsed_time:.2f} seconds\n")
+
+    trainer.save_model(args.output_dir)
+
+    # free the memory again
+    del model
+    del trainer
+    torch.cuda.empty_cache()

code/fine_tuning/fine_tuning_OpenAI_run_inference.py

@@ -0,0 +1,104 @@
+import json
+import os
+import pandas as pd
+import getpass
+
+from PIL import Image
+import io
+import base64
+from datetime import datetime
+
+import use_vlm_ft_OpenAI
+
+
+def get_img_base64_str(image_path):
+    img = Image.open(image_path)
+    buffered = io.BytesIO()
+    img.save(buffered, format=img.format)
+    img_base64_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return img_base64_str
+
+if __name__ == "__main__":
+    api_key = getpass.getpass("Enter your OpenAI API key: ")
+
+    in_path_frame_images        = './.../rpp-765k_512'
+    in_file_data_entering_test  = './.../test.parquet'
+    
+    in_model_name               = "OpenAI_FT_gpt-4o-2024-08-06"
+    in_name_results_output      = 'OpenAI_FT_gpt-4o-2024-08-06'
+    out_path_results            = './.../output'
+
+    path_outputs = os.path.join(out_path_results, in_model_name)
+    os.makedirs(path_outputs, exist_ok=True)
+
+    os.environ["USED_MODEL"] = "gpt-4o-2024-08-06"
+
+    dict_log = {}
+    dict_log['model']           = in_model_name
+    
+    ft_model = "id-of-fine-tuned-model"
+    #######################################################################
+    #######################################################################
+    df_result = pd.DataFrame(
+        columns=['label', 'filename', \
+        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+    df_result_cost = pd.DataFrame(
+        columns=['label', 'filename']
+    )
+
+    df_test     = pd.read_parquet(in_file_data_entering_test, engine='pyarrow')
+    df_test.reset_index(drop=True, inplace=True)
+
+    start_index = 0
+    output_file = f'{datetime.now().strftime("%Y%m%d_%H%M%S")}_{in_name_results_output}'
+    for index, row in df_test.iloc[start_index:].iterrows():
+        label       = str(row.label)
+        filename    = row.filename
+
+        dict_result = {}
+        dict_result['label']    = label
+        dict_result['filename'] = filename
+        dict_result_cost = {}
+        dict_result_cost['label']    = label
+        dict_result_cost['filename'] = filename
+            
+        ############################################
+        # PROMPT
+        ############################################
+        # IMAGE
+        # image_path = os.path.join( in_path_frame_images, 'test', label, filename )
+        image_path = os.path.join( in_path_frame_images, 'train', label, filename )
+        query_image_base64 = get_img_base64_str(image_path)
+
+        # TASK
+        task = "Extract all targets."
+        dict_log['prompt_task'] = task
+
+        dict_log, dict_result, dict_result_cost = use_vlm_ft_OpenAI.do_request(
+            api_key,
+            ft_model,
+            query_image_base64, 
+            task, 
+            dict_log,
+            dict_result, 
+            dict_result_cost,
+        )
+        
+        df_result = pd.concat( [ df_result, pd.DataFrame.from_dict([dict_result]) ], ignore_index=True)
+        df_result_cost = pd.concat( [ df_result_cost, pd.DataFrame.from_dict([dict_result_cost]) ], ignore_index=True)
+
+        if index%100 == 0:
+            df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+            df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+            df_result = pd.DataFrame( columns=['label', 'filename', \
+                        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+            df_result_cost = pd.DataFrame(columns=['label', 'filename'])
+    
+    df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+    df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+
+    #######################################################################
+    #######################################################################
+    
+    with open(os.path.join(path_outputs, in_name_results_output + '.json'), 'w') as json_file:
+        json.dump(dict_log, json_file)

code/fine_tuning/fine_tuning_OpenAI_train_model.md

@@ -0,0 +1,9 @@
+Upload training and validation file:<br>
+<br>
+curl -v https://api.openai.com/v1/files -H "Authorization: Bearer [OpenAI Key]" -F purpose="fine-tune" -F file="@OpenAI_subset_random_train_10250.jsonl"<br>
+curl -v https://api.openai.com/v1/files -H "Authorization: Bearer [OpenAI Key]" -F purpose="fine-tune" -F file="@OpenAI_subset_random_val_2500.jsonl"<br>
+<br>
+<br>
+Start fine-tuning job:<br>
+<br>
+curl -v https://api.openai.com/v1/fine_tuning/jobs -H "Content-Type: application/json" -H "Authorization: Bearer [OpenAI Key]" -d '{ "training_file": "file-[train-file-id]", "validation_file": "file-[val-file-id]", "model": "gpt-4o-2024-08-06", "method" : {"type": "supervised", "supervised": {"hyperparameters": {"n_epochs": 3}}} }'

code/fine_tuning/use_vlm_ft_OpenAI.py

@@ -0,0 +1,230 @@
+import httpx
+import json
+import os
+import requests
+import subprocess
+import time
+
+import openai
+
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing_extensions import List
+from typing import Literal, Optional
+
+from requests.exceptions import ConnectionError
+
+VLM_TEMPERATURE         = 0
+######################################################################
+######################################################################
+
+class WeightUnit(Enum):
+    GRAMM           = "Gramm"
+    KILOGRAM        = "Kilogramm"
+    MILLILITER      = "Milliliter"
+    LITER           = "Liter"
+    WASCHLADUNGEN   = "Waschladungen"
+    BLATT           = "Blatt"
+    STUECK          = "Stück"
+
+class YesNo(Enum):
+    YES = "yes"
+    NO  = "no"
+
+class product_promotion_data(BaseModel):
+    """Collection of product and promotion data of an product advertisement."""
+    brand: str = Field(description="The brand associated with the product")
+    product_category: List[str] = Field(description="List of categories associated with the product.")
+    price: float = Field(description="The promotional price.")
+    regular_price: Optional[float] = Field(default=None, description="The regular price of the promotion.")
+    relative_discount: Optional[int] = Field(default=None, description="The relative discount of the promotion.")
+    absolute_discount: Optional[float] = Field(default=None, description="The absolute discount of the promotion.")
+    GTINs: List[str] = Field(description="List of the GTINs for the products.")
+    weight_number: float = Field(description="Only the numerical weight specication.")
+    # weight_unit: WeightUnit = Field(description="Only the weight unit.")
+    weight_unit: Literal["Gramm", "Kilogramm", "Milliliter", "Liter", "Waschladungen", "Blatt", "Stück"] = Field(description="Only the weight unit.")
+    # different_types: YesNo = Field(description="If promotion offer different sorts.")
+    different_types: Literal["yes", "no"] = Field(description="If promotion offer different sorts.")
+
+######################################################################
+######################################################################
+
+def convert_items_to_strings(prediction):
+    if isinstance(prediction, str):
+        return prediction
+    elif isinstance(prediction, list):
+        return ', '.join(prediction)
+    else:
+        return str(prediction)
+
+def get_output_results(dict_output, dict_result):
+    for key, value in dict_output.items():
+        if key == 'brand':
+            dict_result['brand'] = convert_items_to_strings(dict_output['brand'])
+        elif key == 'product_category':
+            dict_result['product_category'] = convert_items_to_strings(dict_output['product_category'])
+        elif key == 'price':
+            dict_result['price'] = convert_items_to_strings(dict_output['price'])
+        elif key == 'regular_price':
+            dict_result['regular_price'] = convert_items_to_strings(dict_output['regular_price'])
+        elif key == 'relative_discount':
+            dict_result['relative_discount'] = convert_items_to_strings(dict_output['relative_discount'])
+        elif key == 'absolute_discount':
+            dict_result['absolute_discount'] = convert_items_to_strings(dict_output['absolute_discount'])
+        elif key == 'GTINs':
+            dict_result['GTINs'] = convert_items_to_strings(dict_output['GTINs'])
+        elif key == 'weight_number':
+            dict_result['weight_number'] = convert_items_to_strings(dict_output['weight_number'])
+        elif key == 'weight_unit':
+            dict_result['weight_unit'] = convert_items_to_strings(dict_output['weight_unit'])
+        elif key == 'different_types':
+            dict_result['different_types'] = convert_items_to_strings(dict_output['different_types'])
+    return dict_result
+
+
+def prompt(query_image, task, dict_log):
+    system_message = "You are an assistant for question-answering tasks."
+    dict_log['system_message'] = system_message
+
+    human_message_text = "Do the user-provided task on the input image. \
+    The answer must be provided in JSON format. \
+    The task is: " + task + ".\
+    If there is no information of a target, return NaN." 
+    dict_log['human_message_text'] = human_message_text
+
+    human_messages = [
+        {
+            "type": "input_text",
+            "text": human_message_text
+        },
+        {
+            "type": "input_image",
+            "image_url": f"data:image/jpeg;base64,{query_image}",
+        },
+    ]
+
+    input_messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": human_messages}
+    ]
+
+    return dict_log, input_messages
+
+def get_response_format():
+    schema = product_promotion_data.model_json_schema()
+    schema['type'] = 'object'
+    schema['additionalProperties'] = False
+    schema['required'] = list(schema.get('properties', {}).keys())
+    
+    return {
+        "type": "json_schema",
+        "name": "product_promotion_data",
+        "schema": schema
+    }
+
+def do_request(api_key, ft_model, query_image_base64, task, dict_log, dict_result, dict_result_cost):
+    dict_log, messages = prompt(query_image_base64, task, dict_log)
+    response_format = get_response_format()
+
+    try:
+        start_time = time.time()
+        while True:
+            try:
+                payload = {
+                    "model": ft_model,
+                    "input": messages,
+                    "text": {
+                        "format": response_format
+                    }
+                }
+                payload_json = json.dumps(payload)
+                
+                curl_cmd = [
+                    "curl",
+                    f"https://api.openai.com/v1/responses",
+                    "-H", "Content-Type: application/json",
+                    "-H", f"Authorization: Bearer {api_key}",
+                    "-d", payload_json,
+                    "--max-time", "60"     # timeout in seconds
+                ]
+                result = subprocess.run(curl_cmd, capture_output=True, text=True)
+            except:
+                print("FAILED")
+                continue
+            break
+        elapsed_time = time.time() - start_time
+        dict_result_cost['elapsed_time_[s]'] = float("{:.2f}".format(elapsed_time))
+
+        raw = result.stdout
+        response = json.loads(raw)
+
+        if response['output'][0]['content'][0]['text']:
+            dict_result = get_output_results(json.loads(response['output'][0]['content'][0]['text']), dict_result)
+            print('dict_result')
+            print(dict_result)
+        print(response['usage'])
+        dict_result_cost = token_price_evaluation(response['usage'], dict_result_cost)    
+    except (KeyError, IndexError) as e:
+        print(f"Key or index missing: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except openai.BadRequestError as e:
+        print(f"BadRequestError: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except openai.ContentFilterFinishReasonError as e:
+        print(f"ContentFilterFinishReasonError: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except ConnectionError as e:
+        print(f"Connection error occurred: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except ValueError as ve:
+        print(f"Validation error: {ve}")
+        return dict_log, dict_result, dict_result_cost
+    except httpx.HTTPStatusError as e:
+        print(f"HTTPStatusError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+    except openai.RateLimitError as e:
+        print(f"RateLimitError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+    except openai.InternalServerError as e:
+        print(f"InternalServerError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+
+    return dict_log, dict_result, dict_result_cost
+
+# https://ai.google.dev/gemini-api/docs/pricing
+def token_price_evaluation(response, dict_result_cost):
+    PRICING = {
+        "gpt-5-mini": {"input": 0.25 / 1000000, "output": 2.00 / 1000000},
+        "gpt-5": {"input": 1.25 / 1000000, "output": 10.00 / 1000000},
+        "gpt-4o-2024-08-06": {"input": 2.50 / 1000000, "output": 10.00 / 1000000},
+    }
+    MODEL = os.environ["USED_MODEL"]
+
+    # OpenAI payload
+    input_tokens = response['input_tokens']
+    output_tokens = response['output_tokens']
+    total_tokens = response['total_tokens']
+
+    input_cost  = input_tokens * PRICING[MODEL]["input"]
+    output_cost = output_tokens * PRICING[MODEL]["output"]
+    total_cost  = input_cost + output_cost
+
+    print(f"Model Used: {MODEL}")
+    print(f"Input Tokens: {input_tokens}, Cost: ${input_cost:.4f}")
+    print(f"Output Tokens: {output_tokens}, Cost: ${output_cost:.4f}")
+    print(f"Total Tokens: {total_tokens}")
+    print(f"Total Cost: ${total_cost:.4f}")
+    print('*'*30)
+
+    dict_result_cost['input_tokens'] = input_tokens
+    dict_result_cost['output_tokens'] = output_tokens
+    dict_result_cost['total_tokens'] = total_tokens
+    dict_result_cost['total_cost'] = float(total_cost)
+
+    return dict_result_cost

code/fine_tuning/use_vlm_ft_gemma3.py

@@ -0,0 +1,226 @@
+import httpx
+import re
+import requests
+import time
+
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing_extensions import List
+from typing import Literal, Optional
+
+from requests.exceptions import ConnectionError
+
+from PIL import Image
+
+VLM_TEMPERATURE         = 0
+######################################################################
+######################################################################
+
+class WeightUnit(Enum):
+    GRAMM           = "Gramm"
+    KILOGRAM        = "Kilogramm"
+    MILLILITER      = "Milliliter"
+    LITER           = "Liter"
+    WASCHLADUNGEN   = "Waschladungen"
+    BLATT           = "Blatt"
+    STUECK          = "Stück"
+
+class YesNo(Enum):
+    YES = "yes"
+    NO  = "no"
+
+class product_promotion_data(BaseModel):
+    """Collection of product and promotion data of an product advertisement."""
+    brand: str = Field(description="The brand associated with the product")
+    product_category: List[str] = Field(description="List of categories associated with the product.")
+    price: float = Field(description="The promotional price.")
+    regular_price: Optional[float] = Field(default=None, description="The regular price of the promotion.")
+    relative_discount: Optional[int] = Field(default=None, description="The relative discount of the promotion.")
+    absolute_discount: Optional[float] = Field(default=None, description="The absolute discount of the promotion.")
+    GTINs: List[str] = Field(description="List of the GTINs for the products.")
+    weight_number: float = Field(description="Only the numerical weight specication.")
+    # weight_unit: WeightUnit = Field(description="Only the weight unit.")
+    weight_unit: Literal["Gramm", "Kilogramm", "Milliliter", "Liter", "Waschladungen", "Blatt", "Stück"] = Field(description="Only the weight unit.")
+    # different_types: YesNo = Field(description="If promotion offer different sorts.")
+    different_types: Literal["yes", "no"] = Field(description="If promotion offer different sorts.")
+
+######################################################################
+######################################################################
+
+def convert_items_to_strings(prediction):
+    if isinstance(prediction, str):
+        return prediction
+    elif isinstance(prediction, list):
+        return ', '.join(prediction)
+    else:
+        return str(prediction)
+
+def get_output_results(dict_output, dict_result):
+    for key, value in dict_output.items():
+        if key == 'brand':
+            dict_result['brand'] = convert_items_to_strings(dict_output['brand'])
+        elif key == 'product_category':
+            dict_result['product_category'] = convert_items_to_strings(dict_output['product_category'])
+        elif key == 'price':
+            dict_result['price'] = convert_items_to_strings(dict_output['price'])
+        elif key == 'regular_price':
+            dict_result['regular_price'] = convert_items_to_strings(dict_output['regular_price'])
+        elif key == 'relative_discount':
+            dict_result['relative_discount'] = convert_items_to_strings(dict_output['relative_discount'])
+        elif key == 'absolute_discount':
+            dict_result['absolute_discount'] = convert_items_to_strings(dict_output['absolute_discount'])
+        elif key == 'GTINs':
+            dict_result['GTINs'] = convert_items_to_strings(dict_output['GTINs'])
+        elif key == 'weight_number':
+            dict_result['weight_number'] = convert_items_to_strings(dict_output['weight_number'])
+        elif key == 'weight_unit':
+            dict_result['weight_unit'] = convert_items_to_strings(dict_output['weight_unit'])
+        elif key == 'different_types':
+            dict_result['different_types'] = convert_items_to_strings(dict_output['different_types'])
+    return dict_result
+
+
+def prompt(query_image, task, dict_log):
+    system_message = "You are an assistant for question-answering tasks."
+    dict_log['system_message'] = system_message
+
+    human_message_text = "Do the user-provided task on the input image. \
+    The answer must be provided in JSON format. \
+    The task is: " + task + ".\
+    If there is no information of a target, return NaN." 
+    dict_log['human_message_text'] = human_message_text
+
+    input_messages = [
+            {
+                "role": "system",
+                "content": [{"type": "text", "text": system_message}],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image",
+                        "image": query_image,
+                    },
+                    {
+                        "type": "text",
+                        "text": human_message_text,
+                    },
+                ],
+            },
+        ]
+
+    return dict_log, input_messages
+
+def process_vision_info(messages: list[dict]) -> list[Image.Image]:
+    image_inputs = []
+    # Iterate through each conversation
+    for msg in messages:
+        # Get content (ensure it's a list)
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+
+        # Check each content element for images
+        for element in content:
+            if isinstance(element, dict) and (
+                "image" in element or element.get("type") == "image"
+            ):
+                # Get the image and convert to RGB
+                if "image" in element:
+                    image = element["image"]
+                else:
+                    image = element
+                image_inputs.append(image.convert("RGB"))
+    return image_inputs
+
+
+def get_dict_from_output_text(output_text):
+    # Remove the surrounding braces:
+    trimmed = output_text[0].strip('{}').strip()
+
+    # Find all keys with their start positions:
+    # Key pattern: word characters followed by colon
+    matches = list(re.finditer(r'(\b\w+\b)\s*:', trimmed))
+
+    data = {}
+    for i, match in enumerate(matches):
+        key = match.group(1)
+        start = match.end()  # position after colon
+        
+        # end is start of next key or end of string
+        if i+1 < len(matches):
+            end = matches[i+1].start()
+        else:
+            end = len(trimmed)
+        
+        # The value is substring from start:end
+        value = trimmed[start:end].strip().rstrip(',')
+        
+        # Clean value - strip whitespace and trailing commas
+        value = value.strip()
+
+        data[key] = value
+    
+    return data
+
+
+def do_request(ft_model, processor, pil_image, task, dict_log, dict_result, dict_result_cost):
+    dict_log, messages = prompt(pil_image, task, dict_log)
+
+    text = processor.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+
+    # Process the image and text
+    image_inputs = process_vision_info(messages)
+
+    # Tokenize the text and process the images
+    inputs = processor(
+        text=[text],
+        images=image_inputs,
+        padding=True,
+        return_tensors="pt",
+    )
+
+    # Move the inputs to the device
+    inputs = inputs.to(ft_model.device)
+
+    stop_token_ids = [processor.tokenizer.eos_token_id, processor.tokenizer.convert_tokens_to_ids("<end_of_turn>")]
+
+    try:
+        start_time = time.time()
+        try:
+            # Generate the output
+            generated_ids = ft_model.generate(**inputs, max_new_tokens=256, top_p=1.0, do_sample=True, temperature=0.8, eos_token_id=stop_token_ids, disable_compile=True)
+        except:
+            print("FAILED")
+        elapsed_time = time.time() - start_time
+        dict_result_cost['elapsed_time_[s]'] = float("{:.2f}".format(elapsed_time))
+
+        # Trim the generation and decode the output to text
+        generated_ids_trimmed = [out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)]
+        output_text = processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )
+
+        if len(output_text) == 1:
+            dict_output = get_dict_from_output_text(output_text)
+            dict_result = get_output_results(dict_output, dict_result)
+            print('dict_result')
+            print(dict_result)
+    except ConnectionError as e:
+        print(f"Connection error occurred: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except ValueError as ve:
+        print(f"Validation error: {ve}")
+        return dict_log, dict_result, dict_result_cost
+    except httpx.HTTPStatusError as e:
+        print(f"HTTPStatusError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+
+    return dict_log, dict_result, dict_result_cost

code/visual_rag/custom_rag_metrics.py

@@ -0,0 +1,297 @@
+import pandas as pd
+
+
+def get_mean_squared_error(df_true , df_pred, f, df_data_mse_rmse):
+    from sklearn.metrics import mean_squared_error
+
+    df_pred_copy  = df_pred.copy()
+    df_pred_copy[f] = pd.to_numeric(df_pred_copy[f], errors='coerce')
+    
+    mask = df_true[f].notna() & df_pred_copy[f].notna()
+    df_data_mse_rmse.at['non-null GT', f]               = int(df_true[f].notna().value_counts().get(True, 0))
+    df_data_mse_rmse.at['non-null prediction', f]       = int(df_pred_copy[f].notna().value_counts().get(True, 0))
+    df_data_mse_rmse.at['non-null GT AND prediction', f]= int(mask.value_counts().get(True, 0))
+    df_data_mse_rmse.at['null GT', f]                   = int(df_true[f].notna().value_counts().get(False, 0))
+    df_data_mse_rmse.at['null prediction', f]           = int(df_pred_copy[f].notna().value_counts().get(False, 0))
+    df_data_mse_rmse.at['null GT AND prediction', f]    = int(mask.value_counts().get(False, 0))
+    
+    y_true_clean = df_true.loc[mask, f]
+    y_pred_clean = df_pred.loc[mask, f]
+
+    mse = mean_squared_error(y_true_clean, y_pred_clean)
+    df_data_mse_rmse.at['MSE', f] = mse
+    
+    rmse = mean_squared_error(y_true_clean, y_pred_clean, squared=False)
+    df_data_mse_rmse.at['RMSE', f] = rmse
+    
+    return df_data_mse_rmse
+
+
+def get_edit_distances(df_true , df_pred, f, df_edit_distance_brand):
+    mask = df_true[f].notna() & df_pred[f].notna()
+    
+    y_true_clean = df_true.loc[mask, f]
+    y_pred_clean = df_pred.loc[mask, f]
+
+    df_feature_true = pd.DataFrame({
+        f : y_true_clean,
+        f + '_lower' : y_true_clean.str.lower()
+    })
+    df_feature_pred = pd.DataFrame({
+        f : y_pred_clean,
+        f + '_lower' : y_pred_clean.str.lower()
+    })
+
+    df_feature_true = df_feature_true.sort_index()
+    df_feature_pred = df_feature_pred.sort_index()
+
+    df_edit_distance_brand['true_' + f + '_lower'] = df_feature_true[f + '_lower']
+    df_edit_distance_brand['pred_' + f + '_lower'] = df_feature_pred[f + '_lower']
+
+    # Levenshtein distance
+    import Levenshtein
+    lev_dist = [
+        Levenshtein.distance(n1, n2)
+        for n1, n2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['levenshtein_dist'] = lev_dist
+
+    # Hamming Distance
+    ham_dist = [
+        sum(n1 != n2 for n1, n2 in zip(str(s1), str(s2))) if len(str(s1)) == len(str(s2)) else None
+        for s1, s2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['hamming_dist'] = ham_dist
+
+    # Damerau-Levenshtein Distance
+    import textdistance
+    damerau_lev_dist = [
+        textdistance.damerau_levenshtein.distance(str(n1), str(n2)) 
+        for n1, n2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['damerau_levenshtein_dist'] = damerau_lev_dist
+
+    # Jaro Distance
+    jaro_dist = [
+        textdistance.jaro.distance(str(n1), str(n2)) 
+        for n1, n2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['jaro_dist'] = jaro_dist
+
+    return df_edit_distance_brand
+
+
+
+def string_operations(string):
+    import unicodedata
+    import re
+
+    string = string.lower()
+    string = unicodedata.normalize('NFD', string)
+    string = ''.join(char for char in string if unicodedata.category(char) != 'Mn')
+    string = re.sub(r"[']", "", string)
+    
+    return string
+
+def brand_fuzzy_match(str_pred, str_gt):
+    import Levenshtein
+    import re
+
+    distance    = Levenshtein.distance(str_pred, str_gt)
+    similarity  = 1 - (distance / max(len(str_pred), len(str_gt)))
+    
+    if similarity > 0.5:
+        return 1
+    else:
+        words           = re.split(r'\W+', str_pred)
+        list_words_pred = [word for word in words if word]
+        words           = re.split(r'\W+', str_gt)
+        list_words_gt   = [word for word in words if word]
+        if any(item in list_words_gt for item in list_words_pred):
+            return 1
+        else:
+            return 0
+        
+def price_discount_fuzzy_match(f, str_pred, str_gt):
+    if f == 'relative_discount' and str_gt != 'nan':
+        str_gt = str(int(float(str_gt)))
+
+    if str_pred == str_gt:
+        return 1
+    else:
+        return 0
+    
+def product_category_fuzzy_match(str_pred, str_gt):
+    if str_pred == str_gt:
+        return 1
+    else:
+        return 0
+    
+def gtins_fuzzy_match(str_pred, str_gt):
+    if str_pred == str_gt:
+        return 1
+    else:
+        return 0
+    
+def product_weight_fuzzy_match(str_pred, str_gt, weight_number):
+    if str_pred == str_gt:
+        return 1
+    elif str_pred is not None and str_gt is None:
+        return 0
+    else:
+        if 'Gramm' in str_pred and 'Kilogramm' in str_gt:
+            str_pred = str(float(weight_number)/1000) + ' ' + 'Kilogramm'
+            if str_pred == str_gt:
+                return 1
+        elif 'Kilogramm' in str_pred and 'Gramm' in str_gt:
+            str_pred = str(float(weight_number)*1000) + ' ' + 'Gramm'
+            if str_pred == str_gt:
+                return 1
+        elif 'Milliliter' in str_pred and 'Liter' in str_gt:
+            str_pred = str(float(weight_number)/1000) + ' ' + 'Liter'
+            if str_pred == str_gt:
+                return 1
+        elif 'Liter' in str_pred and 'Milliliter' in str_gt:
+            str_pred = str(float(weight_number)*1000) + ' ' + 'Milliliter'
+            if str_pred == str_gt:
+                return 1
+        return 0
+
+
+def different_sorts_fuzzy_match(str_pred, str_gt):
+    if str_pred == str_gt:
+        return 1
+    else:
+        return 0
+
+
+def get_custom_accuracy(df_true, df_pred, f, df_custom_accuracy):    
+    if f != 'product_weight' and f != 'different_types':
+        mask = df_true[f].notna() & df_pred[f].notna()
+        
+        df_custom_accuracy.at['non-null GT', f]                 = int(df_true[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null prediction', f]         = int(df_pred[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null GT AND prediction', f]  = int(mask.value_counts().get(True, 0))
+        df_custom_accuracy.at['null GT', f]                 = int(df_true[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null prediction', f]         = int(df_pred[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null GT AND prediction', f]  = int(mask.value_counts().get(False, 0))
+        
+        y_true_clean = df_true.loc[mask, f]
+        y_pred_clean = df_pred.loc[mask, f]
+
+    if f == 'brand':
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean,
+            f + '_string_op' : y_true_clean.apply(string_operations)
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            f + '_string_op' : y_pred_clean.apply(string_operations)
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            brand_fuzzy_match(pred, gt)
+            for pred, gt in zip(df_feature_pred[f + '_string_op'], df_feature_true[f + '_string_op'])
+        ]
+
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+    
+    elif f == 'price' or f == 'regular_price' or f == 'relative_discount' or f == 'absolute_discount':
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean,
+            f + '_string_op' : y_true_clean
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            f + '_string_op' : y_pred_clean.str.replace('-', '')
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            price_discount_fuzzy_match(f, str(pred), str(gt))
+            for pred, gt in zip(df_feature_pred[f + '_string_op'], df_feature_true[f + '_string_op'])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+    
+    elif f == 'product_weight':
+        df_pred[f] = df_pred['weight_number'].astype(str) + ' ' + df_pred['weight_unit'].astype(str)
+        mask = df_true[f].notna() & df_pred[f].notna()
+        
+        df_custom_accuracy.at['non-null GT', f]                 = int(df_true[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null prediction', f]         = int(df_pred[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null GT AND prediction', f]  = int(mask.value_counts().get(True, 0))
+        df_custom_accuracy.at['null GT', f]                 = int(df_true[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null prediction', f]         = int(df_pred[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null GT AND prediction', f]  = int(mask.value_counts().get(False, 0))
+
+        y_true_clean = df_true.loc[mask, f]
+        y_pred_clean = df_pred.loc[mask, f]
+        y_pred_clean_weight_number  = df_pred.loc[mask, 'weight_number']
+        y_pred_clean_weight_unit    = df_pred.loc[mask, 'weight_unit']
+
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            'weight_number' : y_pred_clean_weight_number,
+            'weight_unit' : y_pred_clean_weight_unit,
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            product_weight_fuzzy_match(str(pred), str(gt), weight_number)
+            for pred, gt, weight_number in zip(df_feature_pred[f], df_feature_true[f], df_feature_pred['weight_number'])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+    
+    elif f == 'different_types':
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            different_sorts_fuzzy_match(str(pred), str(gt))
+            for pred, gt in zip(df_true[f], df_pred[f])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+
+    elif f == 'product_category':
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean,
+            f + '_string_op' : y_true_clean
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            f + '_string_op' : y_pred_clean
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            product_category_fuzzy_match(str(pred), str(gt))
+            for pred, gt in zip(df_feature_pred[f + '_string_op'], df_feature_true[f + '_string_op'])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+    
+    elif f == 'GTINs':
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean,
+            f + '_string_op' : y_true_clean
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            f + '_string_op' : y_pred_clean
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            gtins_fuzzy_match(str(pred), str(gt))
+            for pred, gt in zip(df_feature_pred[f + '_string_op'], df_feature_true[f + '_string_op'])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+
+    return df_custom_accuracy

code/visual_rag/evaluation_rag.ipynb

@@ -0,0 +1,579 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78b02192",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import os\n",
+    "\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7405fa4d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install Levenshtein\n",
+    "%pip install textdistance\n",
+    "%pip install scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "489bd187",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_test = pd.read_parquet('./.../test.parquet', engine='pyarrow')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "54b43403",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path_to_vlm_results = \"./.../vlm_results\"\n",
+    "vlm_name            = \"your-vlm-name\"\n",
+    "file_vlm_results    = \"./.../your-vlm-results.parquet\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d414ef1f",
+   "metadata": {},
+   "source": [
+    "# Evaluation of VLM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5c664ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm = pd.read_parquet(os.path.join(path_to_vlm_results, file_vlm_results), engine='pyarrow')\n",
+    "df_vlm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19e6c03f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output_path = os.path.join('results', vlm_name)\n",
+    "os.makedirs(output_path, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a727018d",
+   "metadata": {},
+   "source": [
+    "check if all images have a response"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e89a881",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm.loc[df_vlm.iloc[:, 2:12].isna().all(axis=1)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6874064",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "number_no_prediction = len(df_vlm.loc[df_vlm.iloc[:, 2:12].isna().all(axis=1)].filename.tolist())\n",
+    "print('number of images that have no prediction: ' + str(number_no_prediction))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88081381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = {}\n",
+    "data['number_no_prediction'] = int(number_no_prediction)\n",
+    "\n",
+    "with open(os.path.join(output_path, \"data.json\"), \"w\") as file:\n",
+    "    json.dump(data, file, indent=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6cbbd3c7",
+   "metadata": {},
+   "source": [
+    "# Evaluation Metric: Single Target"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c34d6ec7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import custom_rag_metrics\n",
+    "\n",
+    "import importlib\n",
+    "importlib.reload(custom_rag_metrics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e90eb78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list_features = ['brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'product_weight', 'different_types']\n",
+    "\n",
+    "df_data_mse_rmse        = pd.DataFrame()\n",
+    "df_edit_distance_brand  = pd.DataFrame()\n",
+    "df_custom_accuracy      = pd.DataFrame()\n",
+    "\n",
+    "df_vlm['different_types'] = df_vlm['different_types'].apply(lambda x: x if x == 'yes' else None)\n",
+    "\n",
+    "for f in list_features:\n",
+    "    print(f)\n",
+    "    if 'price' in f or 'discount' in f:\n",
+    "        df_data_mse_rmse = custom_rag_metrics.get_mean_squared_error(df_test, df_vlm, f, df_data_mse_rmse)\n",
+    "    elif f == 'brand':\n",
+    "        df_edit_distance_brand = custom_rag_metrics.get_edit_distances(df_test, df_vlm, f, df_edit_distance_brand)\n",
+    "    \n",
+    "    df_custom_accuracy = custom_rag_metrics.get_custom_accuracy(df_test, df_vlm, f, df_custom_accuracy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc194696",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_data_mse_rmse.to_parquet(os.path.join(output_path, vlm_name + '_mse_rmse.parquet'), engine='pyarrow')\n",
+    "df_data_mse_rmse"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf79860e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_edit_distance_brand.to_parquet(os.path.join(output_path, vlm_name + '_edit_distance_brand.parquet'), engine='pyarrow')\n",
+    "df_edit_distance_brand"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2dc1346a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean_values = df_edit_distance_brand[['levenshtein_dist', 'hamming_dist', 'damerau_levenshtein_dist', 'jaro_dist']].mean()\n",
+    "mean_values.to_csv(os.path.join(output_path, vlm_name + '_edit_distance_brand_mean_values.csv'), header=True)\n",
+    "mean_values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1d9374a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for column in ['levenshtein_dist', 'hamming_dist', 'damerau_levenshtein_dist', 'jaro_dist']:\n",
+    "    plt.figure()\n",
+    "    df_edit_distance_brand.boxplot(column=column)\n",
+    "    plt.savefig(os.path.join(output_path, vlm_name + f'_boxplot_{column}.png'))\n",
+    "    plt.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9dad775",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_custom_accuracy.to_parquet(os.path.join(output_path, vlm_name + '_custom_accuracy.parquet'), engine='pyarrow')\n",
+    "df_custom_accuracy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d486fc3",
+   "metadata": {},
+   "source": [
+    "# Evaluation of costs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7e42d7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vlm_name            = \"your-vlm-name\"\n",
+    "file_vlm_results    = \"./.../your-vlm-results_of_costs.parquet\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c86f9406",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output_path = os.path.join('results', vlm_name)\n",
+    "os.makedirs(output_path, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d64a7f32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm_costs = pd.read_parquet(os.path.join(path_to_vlm_results, file_vlm_results), engine='pyarrow')\n",
+    "df_vlm_costs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aabc0cd2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "columns_to_describe = ['elapsed_time_[s]']\n",
+    "\n",
+    "describe_df = df_vlm_costs[columns_to_describe].describe()\n",
+    "describe_df.to_parquet(os.path.join(output_path, vlm_name + '_costs_describe.parquet'), engine='pyarrow')\n",
+    "describe_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cfe082fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# total elapsed time (all req.)\n",
+    "df_vlm_costs['elapsed_time_[s]'].sum()\n",
+    "# in hours\n",
+    "df_vlm_costs['elapsed_time_[s]'].sum() / 60 / 60"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "705293de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm_costs['total_cost'].sum()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e8d2c216",
+   "metadata": {},
+   "source": [
+    "# Evaluation Metric: Union Targets and Union Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a42a6088",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tqdm import tqdm\n",
+    "import custom_rag_metrics\n",
+    "import importlib\n",
+    "importlib.reload(custom_rag_metrics)\n",
+    "\n",
+    "def string_operations(string):\n",
+    "    import unicodedata\n",
+    "    import re\n",
+    "\n",
+    "    string = string.lower()\n",
+    "    string = unicodedata.normalize('NFD', string)\n",
+    "    string = ''.join(char for char in string if unicodedata.category(char) != 'Mn')\n",
+    "    string = re.sub(r\"[']\", \"\", string)\n",
+    "    \n",
+    "    return string\n",
+    "\n",
+    "df_vlm = pd.read_parquet(os.path.join(path_to_vlm_results, file_vlm_results), engine='pyarrow')\n",
+    "df_vlm['different_types'] = df_vlm['different_types_manually'].apply(lambda x: x if x == 'yes' else None)\n",
+    "\n",
+    "list_features = ['brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'product_weight', 'different_types']\n",
+    "\n",
+    "df_custom_accuracy_total = pd.DataFrame(columns=df_vlm.columns)\n",
+    "df_custom_accuracy_total.drop('weight_number', axis=1, inplace=True)\n",
+    "df_custom_accuracy_total.drop('weight_unit', axis=1, inplace=True)\n",
+    "df_custom_accuracy_total['product_weight'] = None\n",
+    "df_custom_accuracy_total['label'] = df_vlm['label']\n",
+    "df_custom_accuracy_total['filename'] = df_vlm['filename']\n",
+    "\n",
+    "for i, f in enumerate(list_features):\n",
+    "    print(f)\n",
+    "\n",
+    "    for index, row in tqdm(df_vlm.iterrows(), total=len(df_vlm)):\n",
+    "        if f != 'product_weight':\n",
+    "            y_pred = row[f]\n",
+    "        \n",
+    "        y_true = df_test.iloc[index][f]\n",
+    "\n",
+    "        if y_pred is None:\n",
+    "            df_custom_accuracy_total.at[index, f] = 0\n",
+    "            continue\n",
+    "        \n",
+    "        if f == 'brand':\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_rag_metrics.brand_fuzzy_match(string_operations(y_pred), string_operations(y_true))\n",
+    "        elif 'price' in f or 'discount' in f:            \n",
+    "            df_custom_accuracy_total.at[index, f] = custom_rag_metrics.price_discount_fuzzy_match(f, y_pred.replace('-', ''), str(y_true))\n",
+    "        elif f == 'different_types':\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_rag_metrics.different_sorts_fuzzy_match(y_pred, str(y_true))\n",
+    "        elif f == 'product_weight':\n",
+    "            if row['weight_number'] is None or row['weight_unit'] is None:\n",
+    "                df_custom_accuracy_total.at[index, f] = 0\n",
+    "                continue\n",
+    "\n",
+    "            y_pred = row['weight_number'] + ' ' + row['weight_unit']\n",
+    "            weight_number  = row['weight_number']\n",
+    "\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_rag_metrics.product_weight_fuzzy_match(y_pred, y_true, weight_number)\n",
+    "        elif f == 'product_category':\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_rag_metrics.product_category_fuzzy_match(y_pred, y_true)\n",
+    "        elif f == 'GTINs':\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_rag_metrics.gtins_fuzzy_match(y_pred, y_true)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4403d83a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_custom_accuracy_total"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8995eaf3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# uncomment the set of targets for which the evaluation should be done\n",
+    "\n",
+    "cols = ['brand']\n",
+    "# cols = ['brand', 'product_weight']\n",
+    "# cols = ['brand', 'product_weight', 'different_types']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price', 'relative_discount']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price', 'relative_discount', 'product_category']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price', 'relative_discount', 'product_category', 'GTINs']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price', 'relative_discount', 'product_category', 'GTINs', 'absolute_discount']\n",
+    "df_custom_accuracy_total.loc[(df_custom_accuracy_total[cols] == 1).all(axis=1)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77728f07",
+   "metadata": {},
+   "source": [
+    "#### total custom accuracy regard to WHOLE test dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "000737bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tmp = df_custom_accuracy_total.loc[(df_custom_accuracy_total[cols] == 1).all(axis=1)]\n",
+    "len(tmp) / 36571 * 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1502be2e",
+   "metadata": {},
+   "source": [
+    "#### total custom accuracy regard to VALID GT & PRED values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3381e144",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm['product_weight'] = df_vlm['weight_number'].astype(str) + ' ' + df_vlm['weight_unit'].astype(str)\n",
+    "\n",
+    "tmp = df_custom_accuracy_total.loc[(df_custom_accuracy_total[cols] == 1).all(axis=1)]\n",
+    "\n",
+    "mask = df_test[cols].notna().all(axis=1) & df_vlm[cols].notna().all(axis=1)\n",
+    "length = int(mask.value_counts().get(True, 0))\n",
+    "\n",
+    "print(len(tmp))\n",
+    "print(length)\n",
+    "\n",
+    "len(tmp) / length * 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1fdf2ef",
+   "metadata": {},
+   "source": [
+    "### create boxplot for price"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "810f3459",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "df_test = pd.read_parquet('path-to-file/test.parquet', engine='pyarrow')\n",
+    "df_true = df_test.copy()\n",
+    "path_to_vlm_results = \"path-to-results\"\n",
+    "\n",
+    "list_model = [\n",
+    "    \"your-vlm-name\",\n",
+    "]\n",
+    "\n",
+    "list_features = ['price']\n",
+    "df_price_errors = pd.DataFrame()\n",
+    "for f in list_features:\n",
+    "    # all_errors = []\n",
+    "    for m in list_model:\n",
+    "        df_vlm = pd.read_parquet(os.path.join(path_to_vlm_results, m, m + '_test.parquet'), engine='pyarrow')\n",
+    "        mask = df_true[f].notna() & df_vlm[f].notna()\n",
+    "        y_true_clean = df_true.loc[mask, f]\n",
+    "        y_pred_clean = df_vlm.loc[mask, f].astype(float)\n",
+    "        errors_y = y_true_clean - y_pred_clean\n",
+    "        \n",
+    "        # Create a DataFrame from errors_y with column named by model\n",
+    "        df_model_errors = pd.DataFrame({m: errors_y})\n",
+    "\n",
+    "        # Concatenate preserving indices, axis=1 will join columns side-by-side\n",
+    "        df_price_errors = pd.concat([df_price_errors, df_model_errors], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e14db8eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "########################################\n",
+    "plt.rcdefaults() # set default settings\n",
+    "plt.figure(figsize=(8, 5))\n",
+    "plt.rcParams.update({\n",
+    "    \"text.usetex\": True,          # Use LaTeX to render all text\n",
+    "    \"font.family\": \"serif\",       # Use serif font (matching typical LaTeX documents)\n",
+    "    # \"text.latex.preamble\": r\"\\usepackage{lmodern}\"\n",
+    "    \"font.size\": 12,           # base font size for text\n",
+    "    \"axes.titlesize\": 14,      # title font size\n",
+    "    \"axes.labelsize\": 13,      # axis labels font size\n",
+    "    \"xtick.labelsize\": 11,     # x tick labels font size\n",
+    "    \"ytick.labelsize\": 11,     # y tick labels font size\n",
+    "    \"legend.fontsize\": 12,     # legend font size    \n",
+    "})\n",
+    "from matplotlib.ticker import FuncFormatter, StrMethodFormatter\n",
+    "plt.gca().yaxis.set_major_formatter(StrMethodFormatter('{x:,.0f}'))  # comma as thousands separator\n",
+    "def format_with_commas(x, pos):\n",
+    "    return f\"{x:,.2f}\"\n",
+    "plt.gca().xaxis.set_major_formatter(FuncFormatter(format_with_commas))\n",
+    "########################################\n",
+    "\n",
+    "# Simple boxplot for each column (model)\n",
+    "df_price_errors.boxplot()\n",
+    "\n",
+    "list_legend = [\n",
+    "    \"your-vlm-name\",\n",
+    "]\n",
+    "\n",
+    "\n",
+    "# Set custom x-axis tick labels\n",
+    "plt.xticks(ticks=range(1, len(list_legend)+1), labels=list_legend)\n",
+    "\n",
+    "plt.ylabel('Prediction Error (Currency: EUR)')\n",
+    "plt.xlabel('Model')\n",
+    "\n",
+    "plt.savefig(\"boxplot_price.pdf\", bbox_inches='tight')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "latex",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

code/visual_rag/rag_retriever.py

@@ -0,0 +1,30 @@
+from typing import List
+from pydantic import BaseModel
+
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.documents import Document
+from langchain_core.vectorstores import VectorStore
+from langchain_core.embeddings import Embeddings
+
+class custom_retriever(BaseRetriever, BaseModel):
+    vector_store: VectorStore
+    embeddings: Embeddings
+    k: int
+
+    def _get_relevant_documents(self, query: str) -> List[Document]:
+        query_type = query.split('*-*')[0]
+        query = query.split('*-*')[1]
+        
+        if query_type == 'text':
+            query_embedding = self.embeddings.embed_documents([query])
+        elif query_type == 'image':
+            query_embedding = self.embeddings.embed_image([query])
+        
+        list_doc_dis = self.vector_store.similarity_search_by_vector_with_relevance_scores(
+            embedding = query_embedding,
+            k = self.k
+        )
+        doc     = [item[0] for item in list_doc_dis]
+        dis     = [item[1] for item in list_doc_dis]
+
+        return doc, dis

code/visual_rag/rag_use_vlm.py

@@ -0,0 +1,385 @@
+import base64
+import io
+import json
+import openai
+import os
+import requests
+import time
+
+from PIL import Image
+
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing_extensions import List
+from typing import Literal
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_ollama import ChatOllama
+
+VLM_SEED                = 0
+VLM_TEMPERATURE         = 0
+######################################################################
+######################################################################
+
+class WeightUnit(Enum):
+    GRAMM           = "Gramm"
+    KILOGRAM        = "Kilogramm"
+    MILLILITER      = "Milliliter"
+    LITER           = "Liter"
+    WASCHLADUNGEN   = "Waschladungen"
+    BLATT           = "Blatt"
+    STUECK          = "Stück"
+
+class YesNo(Enum):
+    YES = "yes"
+    NO  = "no"
+
+class product_promotion_data(BaseModel):
+    """Collection of product and promotion data of an product advertisement."""
+    brand: str = Field(description="The brand associated with the product")
+    product_category: List[str] = Field(description="List of categories associated with the product.")
+    price: float = Field(description="The promotional price.")
+    regular_price: float = Field(default=None, description="The regular price of the promotion.")
+    relative_discount: int = Field(default=None, description="The relative discount of the promotion.")
+    absolute_discount: float = Field(default=None, description="The absolute discount of the promotion.")
+    GTINs: List[str] = Field(description="List of the GTINs for the products.")
+    weight_number: float = Field(description="Only the numerical weight specication.")
+    weight_unit: WeightUnit = Field(description="Only the weight unit.")
+    # weight_unit: Literal["Gramm", "Kilogramm", "Milliliter", "Liter", "Waschladungen", "Blatt", "Stück"] = Field(description="Only the weight unit.")
+    different_sorts: YesNo = Field(description="If promotion offer different sorts.")
+    # different_types: Literal["yes", "no"] = Field(description="If promotion offer different sorts.")
+
+######################################################################
+######################################################################
+
+def get_openai_client(key, model_name, context_str_len):
+    kwargs = {
+        "model": model_name,
+        "api_key": key,
+        "temperature": VLM_TEMPERATURE,
+        "seed": VLM_SEED,
+    }
+    client = ChatOpenAI(**kwargs)
+
+    os.environ["USED_MODEL"] = model_name
+    os.environ["CONTEXT_STRING_LENGTH"] = str(context_str_len)
+
+    return client
+
+def get_google_client(key, model_name, context_str_len):
+    kwargs = {
+        "model": model_name,
+        "api_key": key,
+        "temperature": VLM_TEMPERATURE,
+    }
+
+    client = ChatGoogleGenerativeAI(**kwargs)
+    print(client)
+
+    os.environ["USED_MODEL"] = model_name
+    os.environ["CONTEXT_STRING_LENGTH"] = str(context_str_len)
+
+    return client
+
+def set_ollama_settings(ip_address, model_name, context_str_len):
+    kwargs = {
+        "model": model_name,
+        "base_url": "your-request-url",
+        "temperature": VLM_TEMPERATURE,
+        "seed": VLM_SEED,
+    }
+    client = ChatOllama(**kwargs)
+
+    os.environ["USED_MODEL"] = model_name
+    os.environ["CONTEXT_STRING_LENGTH"] = str(context_str_len)
+    os.environ["IP_ADDRESS"] = ip_address
+    return client
+
+
+def prompt(query_image, question, dict_reference_data, index_neighbor=-1):
+    # Join the context into a single string
+    context = ''
+    for index, (image, text) in enumerate(zip(dict_reference_data['reference_data']['image'], dict_reference_data['reference_data']['text'])):
+        if index_neighbor != -1 and index != index_neighbor:
+            continue
+        tmp = 'image: ' + image + ' and its context: ' + text + "\n\n"
+        # condition due to maximum token length of model
+        if len(context + tmp) <= int(os.environ["CONTEXT_STRING_LENGTH"]):
+            context += tmp
+        else:
+            break
+    if index_neighbor == -1:
+        number_ref_data = index+1
+        print('number of reference data: ' + str(number_ref_data))
+    else:
+        number_ref_data = index_neighbor
+        print('number of reference data: 1')
+
+    system_message = "You are an assistant for question-answering tasks. \
+    You will receive examples of a reference image and its accompanying text. \
+    Using this data, you learn the meanings of different features by linking the text to the image. \
+    Features may be visually present in the image but do not have to be."
+
+    human_message_text = "Do the user-provided task on the input image. \
+    The answer must be provided in JSON format. \
+    The task is: {question}. \
+    The reference images and their context are: \n" + context + "."
+
+    human_messages = [
+        {
+            "type": "text",
+            "text": human_message_text
+        },
+        {
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{query_image}"},
+        },
+    ]
+
+    return number_ref_data, [SystemMessage(content=system_message), HumanMessage(content=human_messages)]
+
+def get_structured_vlm_model(vlm):
+    structured_vlm = vlm.with_structured_output(product_promotion_data, include_raw=True)
+    return structured_vlm
+
+def get_img_base64_str(image_path):
+    img = Image.open(image_path)
+    buffered = io.BytesIO()
+    img.save(buffered, format=img.format)
+    img_base64_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return img_base64_str
+
+# https://platform.openai.com/docs/pricing
+# https://ai.google.dev/gemini-api/docs/pricing
+def token_price_evaluation(response, dict_result_cost):
+    PRICING = {
+        "gpt-4o-2024-08-06": {"input": 2.50 / 1000000, "output": 10.00 / 1000000},
+        "gpt-4o-2024-11-20": {"input": 2.50 / 1000000, "output": 10.00 / 1000000},
+        "gpt-4o-mini-2024-07-18": {"input": 0.15 / 1000000, "output": 0.60 / 1000000},
+        "gpt-4o-mini": {"input": 0.15 / 1000000, "output": 0.60 / 1000000},
+        "gemini/gemini-2.0-flash": {"input": 0.10 / 1000000, "output": 0.40 / 1000000},
+        "gemini-2.5-flash": {"input": 0.30 / 1000000, "output": 2.50 / 1000000},
+    }
+    MODEL = os.environ["USED_MODEL"]
+
+    # OpenAI
+    token_usage = response.response_metadata.get("token_usage", {})
+    input_tokens = token_usage.get("prompt_tokens", 0)
+    output_tokens = token_usage.get("completion_tokens", 0)
+    total_tokens = token_usage.get("total_tokens", input_tokens + output_tokens)
+
+    # Google Gemini
+    # token_usage     = response.usage_metadata
+    # input_tokens    = token_usage.get("input_tokens", 0)
+    # output_tokens   = token_usage.get("output_tokens", 0)
+    # reasoning_tokens= token_usage.get("output_token_details", {}).get("reasoning", 0)
+    # total_tokens    = token_usage.get("total_tokens", input_tokens + output_tokens)
+
+    input_cost = input_tokens * PRICING[MODEL]["input"]
+    output_cost = output_tokens * PRICING[MODEL]["output"]
+    total_cost = input_cost + output_cost
+
+    print(f"Model Used: {MODEL}")
+    print(f"Input Tokens: {input_tokens}, Cost: ${input_cost:.4f}")
+    print(f"Output Tokens: {output_tokens}, Cost: ${output_cost:.4f}")
+    print(f"Total Tokens: {total_tokens}")
+    print(f"Total Cost: ${total_cost:.4f}")
+    print('*'*30)
+
+    dict_result_cost['input_tokens'] = input_tokens
+    dict_result_cost['output_tokens'] = output_tokens
+    # dict_result_cost['reasoning_tokens'] = reasoning_tokens
+    dict_result_cost['total_tokens'] = total_tokens
+    dict_result_cost['total_cost'] = float("{:.4f}".format(total_cost))
+
+    return dict_result_cost
+
+def convert_items_to_strings(prediction):
+    if isinstance(prediction, str): # special case for product weight
+        return prediction
+    elif isinstance(prediction, list):
+        return ', '.join(prediction)
+    else:
+        return str(prediction)
+
+def get_output_results(dict_output, dict_result):
+    for key, value in dict_output.items():
+        if key == 'brand':
+            dict_result['brand'] = convert_items_to_strings(dict_output['brand'])
+        elif key == 'product_category':
+            dict_result['product_category'] = convert_items_to_strings(dict_output['product_category'])
+        elif key == 'price':
+            dict_result['price'] = convert_items_to_strings(dict_output['price'])
+        elif key == 'regular_price':
+            dict_result['regular_price'] = convert_items_to_strings(dict_output['regular_price'])
+        elif key == 'relative_discount':
+            dict_result['relative_discount'] = convert_items_to_strings(dict_output['relative_discount'])
+        elif key == 'absolute_discount':
+            dict_result['absolute_discount'] = convert_items_to_strings(dict_output['absolute_discount'])
+        elif key == 'GTINs':
+            dict_result['GTINs'] = convert_items_to_strings(dict_output['GTINs'])
+        elif key == 'weight_number':
+            dict_result['weight_number'] = convert_items_to_strings(dict_output['weight_number'])
+        elif key == 'weight_unit':
+            # dict_result['weight_unit'] = convert_items_to_strings(dict_output['weight_unit'].value)
+            dict_result['weight_unit'] = convert_items_to_strings(dict_output['weight_unit'])
+        elif key == 'different_sorts':
+            # dict_result['different_sorts'] = convert_items_to_strings(dict_output['different_sorts'].value)
+            dict_result['different_sorts'] = convert_items_to_strings(dict_output['different_sorts'])
+        elif key == 'different_types':
+            dict_result['different_types'] = convert_items_to_strings(dict_output['different_types'])
+    return dict_result
+
+def deleting_neigbor(neighbor, dict_result):
+    dict_result[neighbor + 'label'] = None
+    dict_result[neighbor + 'filename'] = None
+    dict_result[neighbor + 'document'] = None
+    dict_result[neighbor + 'distance'] = None
+    return dict_result
+
+
+def do_ollama_request(messages, query_image_base64):
+    response = requests.post(
+                    "requests-url", 
+                    json={
+                        "model": os.environ["USED_MODEL"],
+                        "prompt": messages[1].content[0]['text'],
+                        "system": messages[0].content,
+                        "stream": False,
+                        "images": [query_image_base64],
+                        "options": {
+                            "temperature": VLM_TEMPERATURE,
+                            "seed": VLM_SEED,
+                        },
+                        "format": product_promotion_data.model_json_schema()
+                    },
+                    timeout=60
+                )
+    parsed = json.loads(response.text)
+    return parsed
+
+
+
+def do_request(query_image_base64, question, dict_reference_data, vlm_rag_structured, dict_result, dict_result_cost, ollama=False):
+    index_neighbor = -1
+    number_ref_data, messages = prompt(query_image_base64, question, dict_reference_data)
+    
+    if ollama:
+        
+        try:
+            start_time = time.time()
+            parsed = do_ollama_request(messages, query_image_base64)
+
+            # reduced context
+            if not parsed['response']:
+                index_neighbor = 0
+                print('index_neighbor = 0')
+                number_ref_data, messages = prompt(query_image_base64, question, dict_reference_data, index_neighbor)
+                parsed = do_ollama_request(messages, query_image_base64)
+                
+                if not parsed['response']:
+                    index_neighbor = 1
+                    print('index_neighbor = 1')
+                    number_ref_data, messages = prompt(query_image_base64, question, dict_reference_data, index_neighbor)
+                    parsed = do_ollama_request(messages, query_image_base64)
+                    
+                    if not parsed['response']:
+                        index_neighbor = 2
+                        print('index_neighbor = 2')
+                        number_ref_data, messages = prompt(query_image_base64, question, dict_reference_data, index_neighbor)
+                        parsed = do_ollama_request(messages, query_image_base64)
+                        
+                        if not parsed['response']:
+                            number_ref_data = -1
+                            print('index_neighbor = -1')
+            elapsed_time = time.time() - start_time
+            dict_result_cost['elapsed_time_[s]'] = float("{:.2f}".format(elapsed_time))
+
+            if parsed['response']:
+                dict_result = get_output_results(json.loads(parsed['response']), dict_result)
+                print('dict_result')
+                print(dict_result)
+
+        except requests.exceptions.RequestException as e:
+            print(f"Request failed: {e}")
+            return dict_result, dict_result_cost
+        except requests.Timeout as e:
+            print(f"Request failed: {e}")
+            return dict_result, dict_result_cost
+        except ValueError as ve:
+            print(f"Validation error: {ve}")
+            return dict_result, dict_result_cost
+        except KeyError as e:
+            print(f"Key error: {e}")
+            return dict_result, dict_result_cost
+        except ConnectionError as e:
+            print(f"Connection error occurred: {e}")
+            return dict_result, dict_result_cost    
+    else:
+        try:
+            start_time = time.time()
+            response = vlm_rag_structured.invoke(messages)
+
+            # reduced context
+            if not response['parsed']:
+                index_neighbor = 0
+                number_ref_data, messages = prompt(query_image_base64, question, dict_reference_data, index_neighbor)
+                response = vlm_rag_structured.invoke(messages)
+                if not response['parsed']:
+                    index_neighbor = 1
+                    number_ref_data, messages = prompt(query_image_base64, question, dict_reference_data, index_neighbor)
+                    response = vlm_rag_structured.invoke(messages)
+                    if not response['parsed']:
+                        index_neighbor = 2
+                        number_ref_data, messages = prompt(query_image_base64, question, dict_reference_data, index_neighbor)
+                        response = vlm_rag_structured.invoke(messages)
+                        if not response['parsed']:
+                            number_ref_data = -1
+            elapsed_time = time.time() - start_time
+            dict_result_cost['elapsed_time_[s]'] = float("{:.2f}".format(elapsed_time))
+
+            if response['parsed']:
+                dict_result = get_output_results(response['parsed'].dict(), dict_result)
+
+        except openai.BadRequestError as e:
+            print(f"BadRequestError: {e}")
+        except ValueError as ve:
+            print(f"Validation error: {ve}")
+        except openai.LengthFinishReasonError as e:
+            print(f"LengthFinishReasonError: {e}")
+        except openai.InternalServerError as e:
+            print(f"InternalServerError: {e}")
+
+        try:
+            dict_result_cost = token_price_evaluation(response['raw'], dict_result_cost)
+        except Exception as e:
+            print("Error occurred:", e)
+
+    if index_neighbor == -1:
+        if number_ref_data == 2:
+            dict_result = deleting_neigbor('N2_', dict_result)
+        elif number_ref_data == 1:
+            dict_result = deleting_neigbor('N2_', dict_result)
+            dict_result = deleting_neigbor('N1_', dict_result)
+        elif number_ref_data == 0:
+            dict_result = deleting_neigbor('N2_', dict_result)
+            dict_result = deleting_neigbor('N1_', dict_result)
+            dict_result = deleting_neigbor('N0_', dict_result)
+    else:
+        if number_ref_data == 0:
+            dict_result = deleting_neigbor('N2_', dict_result)
+            dict_result = deleting_neigbor('N1_', dict_result)
+        elif number_ref_data == 1:
+            dict_result = deleting_neigbor('N2_', dict_result)
+            dict_result = deleting_neigbor('N0_', dict_result)
+        elif number_ref_data == 2:
+            dict_result = deleting_neigbor('N1_', dict_result)
+            dict_result = deleting_neigbor('N0_', dict_result)
+        elif number_ref_data == -1:
+            dict_result = deleting_neigbor('N2_', dict_result)
+            dict_result = deleting_neigbor('N1_', dict_result)
+            dict_result = deleting_neigbor('N0_', dict_result)
+    
+    return dict_result, dict_result_cost

code/visual_rag/rag_vector_store.py

@@ -0,0 +1,28 @@
+import chromadb
+import os
+
+from langchain_chroma import Chroma
+from langchain_experimental.open_clip import OpenCLIPEmbeddings
+
+######################################################################
+######################################################################
+
+def get_open_clip_embedding(model_name, checkpoint):
+    embedding_function = OpenCLIPEmbeddings(
+        model_name=model_name, 
+        checkpoint=checkpoint,
+    )
+
+    return embedding_function
+
+def get_chroma_vector_db(path_to_vector_db, name_vector_store, collection_name, embedding_function):
+    chroma_client = chromadb.PersistentClient(path = os.path.join(path_to_vector_db, name_vector_store))
+    
+    vectorstore_disk_saved = Chroma(
+        client              = chroma_client,
+        persist_directory   = path_to_vector_db,
+        collection_name     = collection_name,
+        embedding_function  = embedding_function,
+    )
+    
+    return vectorstore_disk_saved

code/visual_rag/run_rag_pipeline.py

@@ -0,0 +1,261 @@
+import base64
+import glob
+import io
+import json
+import os
+import pandas as pd
+import time
+
+from PIL import Image
+from pydantic import ValidationError
+
+import rag_vector_store
+import rag_retriever
+import rag_use_vlm
+
+NUMBER_EXAMPLES_IN_PROMPT = 3
+NUMBER_NEIGHBOUR = 5
+
+######################################################################
+######################################################################
+
+def most_frequent_label(lst):
+    return max(lst, key=lst.count)
+
+def get_img_base64_str(image_path):
+    img = Image.open(image_path)
+    buffered = io.BytesIO()
+    img.save(buffered, format=img.format)
+    img_base64_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return img_base64_str
+
+
+###################################################################################################################################
+###################################################################################################################################
+###################################################################################################################################
+if __name__ == '__main__':
+
+    in_path_frame_images        = './.../rpp-765k_512'
+    in_file_data_entering_train = './.../train.parquet'
+    in_file_data_entering_test  = './.../test.parquet'
+
+    in_path_product_image_test          = "./.../folder-to-only-product-images"
+    in_file_predicted_description_test  = "./.../file-of-predicted-description"
+    in_path_vector_store                = "./.../vector_db"
+    in_name_vector_db_name              = "name-of-vector-store"
+    in_name_vector_db_collection        = "name-of-vector-store-collection"
+    out_path_results                    = "./.../output"
+
+    in_name_results_output  = "results"
+    in_model_type           = "custom-model-type"
+
+    path_outputs = os.path.join(out_path_results, in_name_results_output)
+    os.makedirs(path_outputs, exist_ok=True)
+
+    dict_rag_approach = {}
+    dict_rag_approach['dataset']                = 'rpp-765k_512'
+    dict_rag_approach['vector_store']           = in_name_vector_db_name
+
+    #######################################################################
+    #######################################################################
+    key         = "your-api-key"
+    model_name  = "your-vector-store-model"
+    checkpoint  = "your-vector-store-checkpoint"
+
+    embedding_function = rag_vector_store.get_open_clip_embedding(
+        model_name = model_name, 
+        checkpoint = checkpoint,
+    )
+    
+    vector_store = rag_vector_store.get_chroma_vector_db(
+        path_to_vector_db   = in_path_vector_store, 
+        name_vector_store   = in_name_vector_db_name, 
+        collection_name     = in_name_vector_db_collection,
+        embedding_function  = embedding_function,
+    )
+
+    try:
+        retriever_rag = rag_retriever.custom_retriever(
+            vector_store = vector_store,
+            embeddings   = vector_store._embedding_function,
+            k            = NUMBER_NEIGHBOUR,
+        )
+    except ValidationError as e:
+        print(e)
+
+    df_result = pd.DataFrame(
+        columns=['label', 'filename', \
+        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_sorts', 'different_types', \
+        'N0_label', 'N0_filename', 'N0_document', 'N0_distance', \
+        'N1_label', 'N1_filename', 'N1_document', 'N1_distance', \
+        'N2_label', 'N2_filename', 'N2_document', 'N2_distance'])
+    df_result_cost = pd.DataFrame(
+        columns=['label', 'filename']
+    )
+
+    df_train_data_entering          = pd.read_parquet(in_file_data_entering_train, engine='pyarrow')
+    df_test_predicted_description   = pd.read_parquet(in_file_predicted_description_test, engine='pyarrow')
+    df_test_data                    = pd.read_parquet(in_file_data_entering_test, engine='pyarrow')
+    
+    start_index = 0
+    for index, row in df_test_data.iloc[start_index:].iterrows():
+        if in_model_type == "your-model-type":
+            vlm = rag_use_vlm.get_openai_client(key=key, model_name="your-model-name", context_str_len=int("your-context-length"))
+            vlm_rag_structured = rag_use_vlm.get_structured_vlm_model(vlm)
+        elif "ollama" in in_name_results_output:
+            rag_use_vlm.set_ollama_settings(ip_address="your-ip-address", model_name="your-ollama-model-name", context_str_len=int("your-context-length"))
+
+        label       = str(row.label)
+        filename    = row.filename
+
+        dict_result = {}
+        dict_result['label']    = label
+        dict_result['filename'] = filename
+        dict_result_cost = {}
+        dict_result_cost['label']    = label
+        dict_result_cost['filename'] = filename
+    
+        ############################################
+        # PREPROCESSING + RETRIEVE
+        ############################################
+        list_path_products_per_frame = glob.glob(os.path.join(in_path_product_image_test, label, filename.split('.jpg')[0] + '*' ))
+
+        list_retrieve_doc_image = []
+        list_retrieve_dis_image = []
+        for path_product_image in list_path_products_per_frame:
+            retrieve_doc_image, retrieve_dis_image = retriever_rag.invoke('image*-*' + path_product_image)
+            list_retrieve_doc_image   += retrieve_doc_image
+            list_retrieve_dis_image   += retrieve_dis_image
+
+        df_predicted_text = df_test_predicted_description.loc[df_test_predicted_description.filename == filename.split('.')[0] + '_wo_product.jpg']
+        if len(df_predicted_text) == 0:
+            df_result = pd.concat( [ df_result, pd.DataFrame.from_dict([dict_result]) ], ignore_index=True)
+            df_result_cost = pd.concat( [ df_result_cost, pd.DataFrame.from_dict([dict_result_cost]) ], ignore_index=True)
+            continue
+        predicted_text_frame_wo = df_predicted_text['product_description_text'].values[0]
+        if predicted_text_frame_wo is None:
+            df_result = pd.concat( [ df_result, pd.DataFrame.from_dict([dict_result]) ], ignore_index=True)
+            df_result_cost = pd.concat( [ df_result_cost, pd.DataFrame.from_dict([dict_result_cost]) ], ignore_index=True)
+            continue
+
+        retrieve_doc_text, retrieve_dis_text = retriever_rag.invoke('text*-*' + predicted_text_frame_wo)
+
+        list_cls_label_image    = [int(doc.metadata['path'].split('/')[-2]) for doc in list_retrieve_doc_image]
+        list_cls_label_text     = [int(doc.metadata['path'].split('/')[-2]) for doc in retrieve_doc_text]
+        cls_label = most_frequent_label(list_cls_label_image + list_cls_label_text)
+
+        # getting all frame images and data entering info of images that belong to cls_label and were retrieved
+        indices             = [idx for idx, value in enumerate(list_cls_label_image) if value == cls_label]
+        list_label_image    = [list_retrieve_doc_image[idx].metadata['path'].split('/')[-2] for idx in indices]
+        list_frame_image    = [list_retrieve_doc_image[idx].metadata['path'].split('/')[-1].split('_')[0] + '.jpg' for idx in indices]
+        list_dis_image      = [list_retrieve_dis_image[idx] for idx in indices]
+    
+        indices         = [idx for idx, value in enumerate(list_cls_label_text) if value == cls_label]
+        list_label_text = [retrieve_doc_text[idx].metadata['path'].split('/')[-2] for idx in indices]
+        list_frame_text = [retrieve_doc_text[idx].metadata['path'].split('/')[-1] for idx in indices]
+        list_dis_text   = [retrieve_dis_text[idx] for idx in indices]
+    
+        df_image = pd.DataFrame({'distance': list_dis_image, 'label': list_label_image, 'filename': list_frame_image, 'document': ['image' for _ in range(len(list_frame_image))]})
+        df_text  = pd.DataFrame({'distance': list_dis_text, 'label': list_label_text, 'filename': list_frame_text, 'document': ['text' for _ in range(len(list_frame_text))]})
+        df_image_text = pd.concat([df_image, df_text], ignore_index=True)
+        
+        df_grouped  = df_image_text.loc[df_image_text.groupby('filename')['distance'].idxmin()]
+        df_sorted   = df_grouped.sort_values(by='distance').reset_index(drop=True)
+        df_sorted['filename']   = df_sorted['filename'].str.replace('_wo_product', '')
+        list_reference_filename = df_sorted['filename'].tolist()
+
+        dict_rag_approach['prompt_number_example_image']    = NUMBER_EXAMPLES_IN_PROMPT
+        dict_rag_approach['prompt_number_example_text']     = NUMBER_EXAMPLES_IN_PROMPT
+
+        for index_vectordb, row_vectordb in df_sorted.iloc[:NUMBER_EXAMPLES_IN_PROMPT].iterrows():
+            neighbor = 'N' + str(index_vectordb) + '_'
+            dict_result[neighbor + 'label'] = row_vectordb.label
+            dict_result[neighbor + 'filename'] = row_vectordb.filename
+            dict_result[neighbor + 'document'] = row_vectordb.document
+            dict_result[neighbor + 'distance'] = row_vectordb.distance
+
+        list_reference_filename = list_reference_filename[:NUMBER_EXAMPLES_IN_PROMPT]
+            
+        ############################################
+        # PROMPT
+        ############################################
+        # IMAGE
+        image_path = os.path.join( in_path_frame_images, 'test', label, filename )
+        query_image_base64 = rag_use_vlm.get_img_base64_str(image_path)
+        
+        # QUESTION
+        question = "Extract all features."
+        dict_rag_approach['prompt_question'] = question
+
+        # REFERENCE DATA
+        dict_reference_data     = {}
+        dict_reference_data['reference_data'] = {}
+        list_ref_image_base64   = []
+        list_ref_text           = []
+
+        for ref_filename in list_reference_filename:
+            tmp_image_bas64 = get_img_base64_str(os.path.join(in_path_frame_images, 'train', str(cls_label), ref_filename))
+            list_ref_image_base64.append(tmp_image_bas64)
+        dict_reference_data['reference_data']['image'] = list_ref_image_base64
+
+        for ref_filename in list_reference_filename:
+            series_row = df_train_data_entering.loc[df_train_data_entering.filename == ref_filename]
+            result = []
+            for idx, value in series_row.items():
+                if idx == 'label' or idx == 'filename':
+                    continue
+                if pd.notnull(value).item():
+                    if idx == 'product_weight':
+                        number = value.values[0].split(' ')[0]
+                        unit = value.values[0].split(' ')[1]
+                        result.append(f"weight_number: {number}")
+                        result.append(f"weight_unit: {unit}")
+                    else: 
+                        result.append(f"{idx}: {value.values[0]}")
+            tmp_text = ", ".join(result)
+            list_ref_text.append(tmp_text)
+
+        dict_reference_data['reference_data']['text'] = list_ref_text
+
+        # adapt call depending on your model type
+        dict_result, dict_result_cost = rag_use_vlm.do_request(
+            query_image_base64, 
+            question, 
+            dict_reference_data, 
+            vlm_rag_structured, 
+            dict_result, 
+            dict_result_cost
+        )
+        
+        df_result = pd.concat( [ df_result, pd.DataFrame.from_dict([dict_result]) ], ignore_index=True)
+        df_result_cost = pd.concat( [ df_result_cost, pd.DataFrame.from_dict([dict_result_cost]) ], ignore_index=True)
+
+        if index%100 == 0:
+            df_result.to_parquet( os.path.join(path_outputs, 'df_result' + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+            df_result_cost.to_parquet( os.path.join(path_outputs, 'df_result' + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+
+            df_result = pd.DataFrame(
+                columns=['label', 'filename', \
+                'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_sorts', 'different_types', \
+                'N0_label', 'N0_filename', 'N0_document', 'N0_distance', \
+                'N1_label', 'N1_filename', 'N1_document', 'N1_distance', \
+                'N2_label', 'N2_filename', 'N2_document', 'N2_distance'])
+            df_result_cost = pd.DataFrame(
+                columns=['label', 'filename']
+            )
+            time.sleep(60)
+
+    #######################################################################
+    #######################################################################
+
+    df_result.to_parquet( os.path.join(path_outputs, 'df_result' + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+    df_result_cost.to_parquet( os.path.join(path_outputs, 'df_result' + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+
+    if in_model_type == "openai" or in_model_type == "gemini":
+        print(f"TOTAL COSTS")
+        sum_of_costs = df_result_cost['total_cost'].sum()
+        sum_of_costs = float(sum_of_costs)
+        print(f"${sum_of_costs:.2f}")
+    
+    with open(os.path.join(path_outputs, in_name_results_output + '.json'), 'w') as json_file:
+        json.dump(dict_rag_approach, json_file)

code/vlm/custom_vlm_metrics.py

@@ -0,0 +1,250 @@
+import pandas as pd
+
+
+def get_mean_squared_error(df_true , df_pred, f, df_data_mse_rmse):
+    from sklearn.metrics import mean_squared_error, root_mean_squared_error
+
+    df_pred_copy  = df_pred.copy()
+    df_pred_copy[f] = pd.to_numeric(df_pred_copy[f], errors='coerce')
+    
+    mask = df_true[f].notna() & df_pred_copy[f].notna()
+    df_data_mse_rmse.at['non-null GT', f]               = int(df_true[f].notna().value_counts().get(True, 0))
+    df_data_mse_rmse.at['non-null prediction', f]       = int(df_pred_copy[f].notna().value_counts().get(True, 0))
+    df_data_mse_rmse.at['non-null GT AND prediction', f]= int(mask.value_counts().get(True, 0))
+    df_data_mse_rmse.at['null GT', f]                   = int(df_true[f].notna().value_counts().get(False, 0))
+    df_data_mse_rmse.at['null prediction', f]           = int(df_pred_copy[f].notna().value_counts().get(False, 0))
+    df_data_mse_rmse.at['null GT AND prediction', f]    = int(mask.value_counts().get(False, 0))
+
+    y_true_clean = df_true.loc[mask, f]
+    y_pred_clean = df_pred_copy.loc[mask, f]
+
+    mse = mean_squared_error(y_true_clean, y_pred_clean)
+    df_data_mse_rmse.at['MSE', f] = mse
+    
+    rmse = root_mean_squared_error(y_true_clean, y_pred_clean)
+    df_data_mse_rmse.at['RMSE', f] = rmse
+    
+    return df_data_mse_rmse
+
+
+def get_edit_distances(df_true , df_pred, f, df_edit_distance_brand):
+    mask = df_true[f].notna() & df_pred[f].notna()
+    
+    y_true_clean = df_true.loc[mask, f]
+    y_pred_clean = df_pred.loc[mask, f]
+
+    df_feature_true = pd.DataFrame({
+        f : y_true_clean,
+        f + '_lower' : y_true_clean.str.lower()
+    })
+    df_feature_pred = pd.DataFrame({
+        f : y_pred_clean,
+        f + '_lower' : y_pred_clean.str.lower()
+    })
+
+    df_feature_true = df_feature_true.sort_index()
+    df_feature_pred = df_feature_pred.sort_index()
+
+    df_edit_distance_brand['true_' + f + '_lower'] = df_feature_true[f + '_lower']
+    df_edit_distance_brand['pred_' + f + '_lower'] = df_feature_pred[f + '_lower']
+
+    # Levenshtein distance
+    import Levenshtein
+    lev_dist = [
+        Levenshtein.distance(n1, n2)
+        for n1, n2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['levenshtein_dist'] = lev_dist
+
+    # Hamming Distance
+    ham_dist = [
+        sum(n1 != n2 for n1, n2 in zip(str(s1), str(s2))) if len(str(s1)) == len(str(s2)) else None
+        for s1, s2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['hamming_dist'] = ham_dist
+
+    # Damerau-Levenshtein Distance
+    import textdistance
+    damerau_lev_dist = [
+        textdistance.damerau_levenshtein.distance(str(n1), str(n2)) 
+        for n1, n2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['damerau_levenshtein_dist'] = damerau_lev_dist
+
+    # Jaro Distance
+    jaro_dist = [
+        textdistance.jaro.distance(str(n1), str(n2)) 
+        for n1, n2 in zip(df_feature_true[f + '_lower'], df_feature_pred[f + '_lower'])
+    ]
+    df_edit_distance_brand['jaro_dist'] = jaro_dist
+
+    return df_edit_distance_brand
+
+
+
+def string_operations(string):
+    import unicodedata
+    import re
+
+    string = string.lower()
+    string = unicodedata.normalize('NFD', string)
+    string = ''.join(char for char in string if unicodedata.category(char) != 'Mn')
+    string = re.sub(r"[']", "", string)
+    
+    return string
+
+def brand_fuzzy_match(str_pred, str_gt):
+    import Levenshtein
+    import re
+
+    distance    = Levenshtein.distance(str_pred, str_gt)
+    similarity  = 1 - (distance / max(len(str_pred), len(str_gt)))
+    
+    if similarity > 0.5:
+        return 1
+    else:
+        words           = re.split(r'\W+', str_pred)
+        list_words_pred = [word for word in words if word]
+        words           = re.split(r'\W+', str_gt)
+        list_words_gt   = [word for word in words if word]
+        if any(item in list_words_gt for item in list_words_pred):
+            return 1
+        else:
+            return 0
+        
+def price_discount_fuzzy_match(f, str_pred, str_gt):
+    if f == 'relative_discount' and str_gt != 'nan':
+        str_gt = str(int(float(str_gt)))
+
+    if str_pred == str_gt:
+        return 1
+    else:
+        return 0
+    
+def product_weight_fuzzy_match(str_pred, str_gt, weight_number):
+    if str_pred == str_gt:
+        return 1
+    elif str_pred is not None and str_gt is None:
+        return 0
+    else:
+        if 'Gramm' in str_pred and 'Kilogramm' in str_gt:
+            str_pred = str(float(weight_number)/1000) + ' ' + 'Kilogramm'
+            if str_pred == str_gt:
+                return 1
+        elif 'Kilogramm' in str_pred and 'Gramm' in str_gt:
+            str_pred = str(float(weight_number)*1000) + ' ' + 'Gramm'
+            if str_pred == str_gt:
+                return 1
+        elif 'Milliliter' in str_pred and 'Liter' in str_gt:
+            str_pred = str(float(weight_number)/1000) + ' ' + 'Liter'
+            if str_pred == str_gt:
+                return 1
+        elif 'Liter' in str_pred and 'Milliliter' in str_gt:
+            str_pred = str(float(weight_number)*1000) + ' ' + 'Milliliter'
+            if str_pred == str_gt:
+                return 1
+        return 0
+
+
+def different_sorts_fuzzy_match(str_pred, str_gt):
+    if str_pred == str_gt:
+        return 1
+    else:
+        return 0
+
+
+def get_custom_accuracy(df_true, df_pred, f, df_custom_accuracy):    
+    if f != 'product_weight' and f != 'different_types':
+        mask = df_true[f].notna() & df_pred[f].notna()
+        
+        df_custom_accuracy.at['non-null GT', f]                 = int(df_true[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null prediction', f]         = int(df_pred[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null GT AND prediction', f]  = int(mask.value_counts().get(True, 0))
+        df_custom_accuracy.at['null GT', f]                 = int(df_true[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null prediction', f]         = int(df_pred[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null GT AND prediction', f]  = int(mask.value_counts().get(False, 0))
+        
+        y_true_clean = df_true.loc[mask, f]
+        y_pred_clean = df_pred.loc[mask, f]
+
+    if f == 'brand':
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean,
+            f + '_string_op' : y_true_clean.apply(string_operations)
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            f + '_string_op' : y_pred_clean.apply(string_operations)
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            brand_fuzzy_match(pred, gt)
+            for pred, gt in zip(df_feature_pred[f + '_string_op'], df_feature_true[f + '_string_op'])
+        ]
+
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+    
+    elif f == 'price' or f == 'regular_price' or f == 'relative_discount' or f == 'absolute_discount':
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean,
+            f + '_string_op' : y_true_clean
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            f + '_string_op' : y_pred_clean.str.replace('-', '')
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            price_discount_fuzzy_match(f, str(pred), str(gt))
+            for pred, gt in zip(df_feature_pred[f + '_string_op'], df_feature_true[f + '_string_op'])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+    
+    elif f == 'product_weight':
+        df_pred[f] = df_pred['weight_number'].astype(str) + ' ' + df_pred['weight_unit'].astype(str)
+        mask = df_true[f].notna() & df_pred[f].notna()
+
+        df_custom_accuracy.at['non-null GT', f]                 = int(df_true[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null prediction', f]         = int(df_pred[f].notna().value_counts().get(True, 0))
+        df_custom_accuracy.at['non-null GT AND prediction', f]  = int(mask.value_counts().get(True, 0))
+        df_custom_accuracy.at['null GT', f]                 = int(df_true[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null prediction', f]         = int(df_pred[f].notna().value_counts().get(False, 0))
+        df_custom_accuracy.at['null GT AND prediction', f]  = int(mask.value_counts().get(False, 0))
+
+        y_true_clean = df_true.loc[mask, f]
+        y_pred_clean = df_pred.loc[mask, f]
+        y_pred_clean_weight_number  = df_pred.loc[mask, 'weight_number']
+        y_pred_clean_weight_unit    = df_pred.loc[mask, 'weight_unit']
+
+        df_feature_true = pd.DataFrame({
+            f : y_true_clean
+        })
+        df_feature_pred = pd.DataFrame({
+            f : y_pred_clean,
+            'weight_number' : y_pred_clean_weight_number,
+            'weight_unit' : y_pred_clean_weight_unit,
+        })
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            product_weight_fuzzy_match(str(pred), str(gt), weight_number)
+            for pred, gt, weight_number in zip(df_feature_pred[f], df_feature_true[f], df_feature_pred['weight_number'])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+    
+    elif f == 'different_types':
+
+        tmp = pd.DataFrame()
+        tmp['match'] = [
+            different_sorts_fuzzy_match(str(pred), str(gt))
+            for pred, gt in zip(df_true[f], df_pred[f])
+        ]
+        from sklearn.metrics import accuracy_score
+        df_custom_accuracy.at['custom_acc', f] = accuracy_score([1]*len(tmp['match']), tmp['match'])
+
+    return df_custom_accuracy

code/vlm/evaluation_vlm.ipynb

@@ -0,0 +1,575 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78b02192",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import os\n",
+    "\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7405fa4d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install Levenshtein\n",
+    "%pip install textdistance\n",
+    "%pip install scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "01b8aa75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_test = pd.read_parquet('./.../test.parquet', engine='pyarrow')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "07196ee1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path_to_vlm_results = \"./.../vlm_results\"\n",
+    "vlm_name            = \"your-vlm-name\"\n",
+    "file_vlm_results    = \"./.../your-vlm-results.parquet\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d414ef1f",
+   "metadata": {},
+   "source": [
+    "# Evaluation of VLM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5c664ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm = pd.read_parquet(os.path.join(path_to_vlm_results, file_vlm_results), engine='pyarrow')\n",
+    "df_vlm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19e6c03f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output_path = os.path.join('results', vlm_name)\n",
+    "os.makedirs(output_path, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a727018d",
+   "metadata": {},
+   "source": [
+    "check if all images have a response"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6874064",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "number_no_prediction = len(df_vlm.loc[df_vlm.iloc[:, 2:12].isna().all(axis=1)].filename.tolist())\n",
+    "print('number of images that have no prediction: ' + str(number_no_prediction))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88081381",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = {}\n",
+    "data['number_no_prediction'] = int(number_no_prediction)\n",
+    "\n",
+    "with open(os.path.join(output_path, \"data.json\"), \"w\") as file:\n",
+    "    json.dump(data, file, indent=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ede59b34",
+   "metadata": {},
+   "source": [
+    "# Evaluation Metric: Single Target"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c34d6ec7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import custom_vlm_metrics\n",
+    "\n",
+    "import importlib\n",
+    "importlib.reload(custom_vlm_metrics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e90eb78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "list_features = ['brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'product_weight', 'different_types']\n",
+    "\n",
+    "df_data_mse_rmse        = pd.DataFrame()\n",
+    "df_edit_distance_brand  = pd.DataFrame()\n",
+    "df_custom_accuracy      = pd.DataFrame()\n",
+    "\n",
+    "df_vlm['different_types'] = df_vlm['different_types'].apply(lambda x: x if x == 'yes' else None)\n",
+    "\n",
+    "for f in list_features:\n",
+    "    print(f)\n",
+    "    if 'price' in f or 'discount' in f:\n",
+    "        df_data_mse_rmse = custom_vlm_metrics.get_mean_squared_error(df_test, df_vlm, f, df_data_mse_rmse)\n",
+    "    elif f == 'brand':\n",
+    "        df_edit_distance_brand = custom_vlm_metrics.get_edit_distances(df_test, df_vlm, f, df_edit_distance_brand)\n",
+    "        \n",
+    "    if f != 'product_category' and f != 'GTINs':\n",
+    "        df_custom_accuracy = custom_vlm_metrics.get_custom_accuracy(df_test, df_vlm, f, df_custom_accuracy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4340f330",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_data_mse_rmse.to_parquet(os.path.join(output_path, vlm_name + '_mse_rmse.parquet'), engine='pyarrow')\n",
+    "df_data_mse_rmse"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10bcccc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_edit_distance_brand.to_parquet(os.path.join(output_path, vlm_name + '_edit_distance_brand.parquet'), engine='pyarrow')\n",
+    "df_edit_distance_brand"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "76fad091",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for column in ['levenshtein_dist', 'hamming_dist', 'damerau_levenshtein_dist', 'jaro_dist']:\n",
+    "    plt.figure()\n",
+    "    df_edit_distance_brand.boxplot(column=column)\n",
+    "    plt.savefig(os.path.join(output_path, vlm_name + f'_boxplot_{column}.png'))\n",
+    "    plt.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f7aaf0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean_values = df_edit_distance_brand[['levenshtein_dist', 'hamming_dist', 'damerau_levenshtein_dist', 'jaro_dist']].mean()\n",
+    "mean_values.to_csv(os.path.join(output_path, vlm_name + '_edit_distance_brand_mean_values.csv'), header=True)\n",
+    "mean_values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08475d4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_custom_accuracy.to_parquet(os.path.join(output_path, vlm_name + '_custom_accuracy.parquet'), engine='pyarrow')\n",
+    "df_custom_accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8dc51a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# different types: valid prediction and GT values\n",
+    "\n",
+    "df = pd.read_parquet(\"./.../your-vlm-results.parquet\", engine='pyarrow')\n",
+    "print(len(df.loc[df.different_types == 'yes'] + df.loc[df.different_types == 'no']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d486fc3",
+   "metadata": {},
+   "source": [
+    "# Evaluation of costs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8698d727",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vlm_name            = \"your-vlm-name\"\n",
+    "file_vlm_results    = \"./.../your-vlm-results_of_costs.parquet\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d64a7f32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm_costs = pd.read_parquet(os.path.join(path_to_vlm_results, file_vlm_results), engine='pyarrow')\n",
+    "df_vlm_costs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac287607",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# total elapsed time (all req.)\n",
+    "df_vlm_costs['elapsed_time_[s]'].sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d880640d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# in hours\n",
+    "df_vlm_costs['elapsed_time_[s]'].sum() / 60 / 60"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aabc0cd2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "columns_to_describe = ['elapsed_time_[s]', 'input_tokens', 'output_tokens', 'total_tokens', 'total_cost']\n",
+    "\n",
+    "describe_df = df_vlm_costs[columns_to_describe].describe()\n",
+    "describe_df.to_parquet(os.path.join(output_path, vlm_name + '_costs_describe.parquet'), engine='pyarrow')\n",
+    "describe_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74795bcc",
+   "metadata": {},
+   "source": [
+    "# Evaluation Metric: Union Targets and Union Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e00c6a78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tqdm import tqdm\n",
+    "import custom_vlm_metrics as custom_vlm_metrics\n",
+    "import importlib\n",
+    "importlib.reload(custom_vlm_metrics)\n",
+    "\n",
+    "print(vlm_name)\n",
+    "print('*'*30)\n",
+    "\n",
+    "def string_operations(string):\n",
+    "    import unicodedata\n",
+    "    import re\n",
+    "\n",
+    "    string = string.lower()\n",
+    "    string = unicodedata.normalize('NFD', string)\n",
+    "    string = ''.join(char for char in string if unicodedata.category(char) != 'Mn')\n",
+    "    string = re.sub(r\"[']\", \"\", string)\n",
+    "    \n",
+    "    return string\n",
+    "\n",
+    "df_vlm = pd.read_parquet(os.path.join(path_to_vlm_results, file_vlm_results), engine='pyarrow')\n",
+    "df_vlm['different_types'] = df_vlm['different_types'].apply(lambda x: x if x == 'yes' else None)\n",
+    "\n",
+    "list_features = ['brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'product_weight', 'different_types']\n",
+    "df_custom_accuracy_total = pd.DataFrame(columns=df_vlm.columns)\n",
+    "df_custom_accuracy_total.drop('weight_number', axis=1, inplace=True)\n",
+    "df_custom_accuracy_total.drop('weight_unit', axis=1, inplace=True)\n",
+    "df_custom_accuracy_total['product_weight'] = None\n",
+    "df_custom_accuracy_total['label'] = df_vlm['label']\n",
+    "df_custom_accuracy_total['filename'] = df_vlm['filename']\n",
+    "\n",
+    "for i, f in enumerate(list_features):\n",
+    "    print(f)\n",
+    "\n",
+    "    for index, row in tqdm(df_vlm.iterrows(), total=len(df_vlm)):\n",
+    "        if f == 'product_category' or f == 'GTINs':\n",
+    "            df_custom_accuracy_total.at[index, f] = 0\n",
+    "            continue\n",
+    "\n",
+    "        if f != 'product_weight':\n",
+    "            y_pred = row[f]\n",
+    "            \n",
+    "        y_true = df_test.iloc[index][f]\n",
+    "\n",
+    "        if y_pred is None:\n",
+    "            df_custom_accuracy_total.at[index, f] = 0\n",
+    "            continue\n",
+    "        \n",
+    "        if f == 'brand':\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_vlm_metrics.brand_fuzzy_match(string_operations(y_pred), string_operations(y_true))\n",
+    "        elif 'price' in f or 'discount' in f:            \n",
+    "            df_custom_accuracy_total.at[index, f] = custom_vlm_metrics.price_discount_fuzzy_match(f, y_pred.replace('-', ''), str(y_true))\n",
+    "        elif f == 'different_types':\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_vlm_metrics.different_sorts_fuzzy_match(y_pred, str(y_true))\n",
+    "        elif f == 'product_weight':\n",
+    "            if row['weight_number'] is None or row['weight_unit'] is None:\n",
+    "                df_custom_accuracy_total.at[index, f] = 0\n",
+    "                continue\n",
+    "\n",
+    "            y_pred = row['weight_number'] + ' ' + row['weight_unit']\n",
+    "            weight_number  = row['weight_number']\n",
+    "\n",
+    "            df_custom_accuracy_total.at[index, f] = custom_vlm_metrics.product_weight_fuzzy_match(y_pred, y_true, weight_number)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e68e00e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_custom_accuracy_total"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bba22b33",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# uncomment the set of targets for which the evaluation should be done\n",
+    "\n",
+    "cols = ['brand']\n",
+    "# cols = ['brand', 'product_weight']\n",
+    "# cols = ['brand', 'product_weight', 'different_types']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price', 'relative_discount']\n",
+    "# cols = ['brand', 'product_weight', 'different_types', 'price', 'regular_price', 'relative_discount', 'absolute_discount']\n",
+    "\n",
+    "df_custom_accuracy_total.loc[(df_custom_accuracy_total[cols] == 1).all(axis=1)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4746ee13",
+   "metadata": {},
+   "source": [
+    "#### total custom accuracy regard to WHOLE test dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ff13437",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tmp = df_custom_accuracy_total.loc[(df_custom_accuracy_total[cols] == 1).all(axis=1)]\n",
+    "len(tmp) / 36571 * 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f97c81f7",
+   "metadata": {},
+   "source": [
+    "#### total custom accuracy regard to VALID GT & PRED values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0c54387",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_vlm['product_weight'] = df_vlm['weight_number'].astype(str) + ' ' + df_vlm['weight_unit'].astype(str)\n",
+    "\n",
+    "tmp = df_custom_accuracy_total.loc[(df_custom_accuracy_total[cols] == 1).all(axis=1)]\n",
+    "\n",
+    "mask = df_test[cols].notna().all(axis=1) & df_vlm[cols].notna().all(axis=1)\n",
+    "length = int(mask.value_counts().get(True, 0))\n",
+    "\n",
+    "len(tmp) / length * 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d20d7ce",
+   "metadata": {},
+   "source": [
+    "#### Create Boxplot for Price"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0946956d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "\n",
+    "df_test             = pd.read_parquet('./.../test.parquet', engine='pyarrow')\n",
+    "df_true             = df_test.copy()\n",
+    "path_to_vlm_results = \"./.../vlm_results\"\n",
+    "\n",
+    "list_model = [\n",
+    "    \"your-vlm-name\",\n",
+    "]\n",
+    "\n",
+    "list_features = ['price']\n",
+    "df_price_errors = pd.DataFrame()\n",
+    "for f in list_features:\n",
+    "    for m in list_model:\n",
+    "        df_vlm = pd.read_parquet(os.path.join(path_to_vlm_results, m + '_test.parquet'), engine='pyarrow')\n",
+    "        mask = df_true[f].notna() & df_vlm[f].notna()\n",
+    "        y_true_clean = df_true.loc[mask, f]\n",
+    "        y_pred_clean = df_vlm.loc[mask, f].astype(float)\n",
+    "        errors_y = y_true_clean - y_pred_clean\n",
+    "        \n",
+    "        # Create a DataFrame from errors_y with column named by model\n",
+    "        df_model_errors = pd.DataFrame({m: errors_y})\n",
+    "\n",
+    "        # Concatenate preserving indices, axis=1 will join columns side-by-side\n",
+    "        df_price_errors = pd.concat([df_price_errors, df_model_errors], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ccb9de3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "########################################\n",
+    "plt.rcdefaults() # set default settings\n",
+    "plt.figure(figsize=(8, 5))\n",
+    "plt.rcParams.update({\n",
+    "    \"text.usetex\": True,          # Use LaTeX to render all text\n",
+    "    \"font.family\": \"serif\",       # Use serif font (matching typical LaTeX documents)\n",
+    "    # \"text.latex.preamble\": r\"\\usepackage{lmodern}\"\n",
+    "    \"font.size\": 12,           # base font size for text\n",
+    "    \"axes.titlesize\": 14,      # title font size\n",
+    "    \"axes.labelsize\": 13,      # axis labels font size\n",
+    "    \"xtick.labelsize\": 11,     # x tick labels font size\n",
+    "    \"ytick.labelsize\": 11,     # y tick labels font size\n",
+    "    \"legend.fontsize\": 12,     # legend font size    \n",
+    "})\n",
+    "from matplotlib.ticker import FuncFormatter, StrMethodFormatter\n",
+    "plt.gca().yaxis.set_major_formatter(StrMethodFormatter('{x:,.0f}'))  # comma as thousands separator\n",
+    "def format_with_commas(x, pos):\n",
+    "    return f\"{x:,.2f}\"\n",
+    "plt.gca().xaxis.set_major_formatter(FuncFormatter(format_with_commas))\n",
+    "########################################\n",
+    "\n",
+    "# Simple boxplot for each column (model)\n",
+    "df_price_errors.boxplot()#rot=45)\n",
+    "\n",
+    "list_legend = [\n",
+    "    \"your-vlm-name\",\n",
+    "]\n",
+    "\n",
+    "# Set custom x-axis tick labels\n",
+    "plt.xticks(ticks=range(1, len(list_legend)+1), labels=list_legend)\n",
+    "\n",
+    "plt.ylabel('Prediction Error (Currency EUR)')\n",
+    "plt.xlabel('Model')\n",
+    "\n",
+    "plt.savefig(\"filename.pdf\", bbox_inches='tight')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "784dc391",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_price_errors.median(numeric_only=True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

code/vlm/run_vlm_commerical.py

@@ -0,0 +1,125 @@
+import base64
+import io
+import json
+import os
+import pandas as pd
+import time
+
+from datetime import datetime
+from PIL import Image
+
+import use_vlm
+
+######################################################################
+######################################################################
+
+def get_img_base64_str(image_path):
+    img = Image.open(image_path)
+    buffered = io.BytesIO()
+    img.save(buffered, format=img.format)
+    img_base64_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return img_base64_str
+
+
+###################################################################################################################################
+###################################################################################################################################
+###################################################################################################################################
+if __name__ == '__main__':   
+    in_key                      = "your-api-key"
+    in_model_name               = "name-of-model-used"
+    
+    in_path_frame_images        = './.../rpp-765k_512'
+    in_file_data_entering_train = './.../train.parquet'
+    in_file_data_entering_test  = './.../test.parquet'
+    
+    in_name_results_output      = 'results'
+    out_path_results            = './.../output'
+
+    path_outputs = os.path.join(out_path_results, in_model_name)
+    os.makedirs(path_outputs, exist_ok=True)
+
+    dict_log = {}
+    dict_log['model']               = in_model_name
+
+    print("in_model_name: " + str(in_model_name))
+
+    #######################################################################
+    #######################################################################
+    df_result = pd.DataFrame(
+        columns=['label', 'filename', \
+        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+    df_result_cost = pd.DataFrame(
+        columns=['label', 'filename']
+    )
+
+    df_train    = pd.read_parquet(in_file_data_entering_train, engine='pyarrow')
+    df_test     = pd.read_parquet(in_file_data_entering_test, engine='pyarrow')
+    
+    print(datetime.now().strftime("%Y%m%d_%H%M%S"))
+
+    start_index = 0
+    output_file = f'{datetime.now().strftime("%Y%m%d_%H%M%S")}_{in_name_results_output}'
+    for index, row in df_test.iloc[start_index:].iterrows():
+
+        vlm = use_vlm.get_openai_client(in_key, in_model_name)
+        if index == 0:
+            print(vlm)
+
+        label       = str(row.label)
+        filename    = row.filename
+
+        dict_result = {}
+        dict_result['label']    = label
+        dict_result['filename'] = filename
+        dict_result_cost = {}
+        dict_result_cost['label']    = label
+        dict_result_cost['filename'] = filename
+
+        print('index')
+        print(index)
+        print('filename')
+        print(filename)
+        print('*'*30)
+            
+        ############################################
+        # PROMPT
+        ############################################
+        # IMAGE
+        image_path = os.path.join( in_path_frame_images, 'test', label, filename )
+        query_image_base64 = get_img_base64_str(image_path)
+
+        # TASK
+        task = "Extract all targets."
+        dict_log['prompt_task'] = task
+
+        dict_log, dict_result, dict_result_cost = use_vlm.do_request(
+            vlm,
+            query_image_base64, 
+            task, 
+            dict_log,
+            dict_result, 
+            dict_result_cost,
+        )
+        
+        df_result = pd.concat( [ df_result, pd.DataFrame.from_dict([dict_result]) ], ignore_index=True)
+        df_result_cost = pd.concat( [ df_result_cost, pd.DataFrame.from_dict([dict_result_cost]) ], ignore_index=True)
+
+        if index%100 == 0:
+            df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+            df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+
+            df_result = pd.DataFrame( columns=['label', 'filename', \
+                        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+            df_result_cost = pd.DataFrame(columns=['label', 'filename'])
+            time.sleep(60)
+
+        print('/'*30)
+    
+    df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+    df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+
+    #######################################################################
+    #######################################################################
+    
+    with open(os.path.join(path_outputs, in_name_results_output + '.json'), 'w') as json_file:
+        json.dump(dict_log, json_file)

code/vlm/run_vlm_ollama.py

@@ -0,0 +1,113 @@
+import base64
+import io
+import json
+import os
+import pandas as pd
+
+from datetime import datetime
+from PIL import Image
+
+import use_vlm_ollama
+
+######################################################################
+######################################################################
+
+def get_img_base64_str(image_path):
+    img = Image.open(image_path)
+    buffered = io.BytesIO()
+    img.save(buffered, format=img.format)
+    img_base64_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return img_base64_str
+
+
+###################################################################################################################################
+###################################################################################################################################
+###################################################################################################################################
+if __name__ == '__main__':   
+    in_model_name               = "your-model-name"
+    in_name_results_output_path = "results"
+    in_name_results_output      = "results-of-your-model"
+    #######################################################################
+
+    in_path_frame_images        = './.../rpp-765k_512'
+    in_file_data_entering_train = './.../train.parquet'
+    in_file_data_entering_test  = './.../test.parquet'
+    out_path_results            = './.../results/'
+
+    path_outputs = os.path.join(out_path_results, in_name_results_output_path)
+    os.makedirs(path_outputs, exist_ok=True)
+
+    dict_log = {}
+    dict_log['model'] = in_model_name
+
+    print("in_model_name: " + str(in_model_name))
+
+    ip_address = "your-ip-address"
+    #######################################################################
+    #######################################################################
+    
+    df_result = pd.DataFrame(
+        columns=['label', 'filename', \
+        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+    df_result_cost = pd.DataFrame(columns=['label', 'filename'])
+
+    df_train    = pd.read_parquet(in_file_data_entering_train, engine='pyarrow')
+    df_test     = pd.read_parquet(in_file_data_entering_test, engine='pyarrow')
+    
+    dict_log['start_time'] = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    start_index = 0
+    output_file = f'{datetime.now().strftime("%Y%m%d_%H%M%S")}_{in_name_results_output}'
+    for index, row in df_test.iloc[start_index:].iterrows():
+        label       = str(row.label)
+        filename    = row.filename
+
+        dict_result = {}
+        dict_result['label']    = label
+        dict_result['filename'] = filename
+        dict_result_cost = {}
+        dict_result_cost['label']    = label
+        dict_result_cost['filename'] = filename
+            
+        ############################################
+        # PROMPT
+        ############################################
+        # IMAGE
+        image_path = os.path.join(in_path_frame_images, 'test', label, filename)
+        query_image_base64 = get_img_base64_str(image_path)
+
+        # TASK
+        task = "Extract all targets."
+        dict_log['prompt_task'] = task
+
+        dict_log, dict_result, dict_result_cost = use_vlm_ollama.do_request(
+            ip_address,
+            in_model_name,
+            query_image_base64,
+            task,
+            dict_log,
+            dict_result,
+            dict_result_cost,
+        )
+        
+        df_result = pd.concat( [ df_result, pd.DataFrame.from_dict([dict_result]) ], ignore_index=True)
+        df_result_cost = pd.concat( [ df_result_cost, pd.DataFrame.from_dict([dict_result_cost]) ], ignore_index=True)
+
+        if index%100 == 0:
+            df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+            df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+
+            df_result = pd.DataFrame( columns=['label', 'filename', \
+                        'brand', 'product_category', 'price', 'regular_price', 'relative_discount', 'absolute_discount', 'GTINs', 'weight_number', 'weight_unit', 'different_types'])
+            df_result_cost = pd.DataFrame(columns=['label', 'filename'])
+    
+    df_result.to_parquet( os.path.join(path_outputs, output_file + '_' + str(index) + '.parquet'), index=False, engine='pyarrow')
+    df_result_cost.to_parquet( os.path.join(path_outputs, output_file + '_costs_' +  str(index) + '.parquet'), index=False, engine='pyarrow')
+
+    #######################################################################
+    #######################################################################
+    
+    dict_log['end_time'] = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    with open(os.path.join(path_outputs, in_name_results_output + '.json'), 'w') as json_file:
+        json.dump(dict_log, json_file)

code/vlm/use_vlm.py

@@ -0,0 +1,217 @@
+import httpx
+import os
+import requests
+import time
+
+import langchain_google_genai
+import langchain_openai
+import openai
+from langchain_core.messages import HumanMessage, SystemMessage
+
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing_extensions import List
+from typing import Literal
+
+from requests.exceptions import ConnectionError
+
+VLM_TEMPERATURE         = 0
+######################################################################
+######################################################################
+
+class WeightUnit(Enum):
+    GRAMM           = "Gramm"
+    KILOGRAM        = "Kilogramm"
+    MILLILITER      = "Milliliter"
+    LITER           = "Liter"
+    WASCHLADUNGEN   = "Waschladungen"
+    BLATT           = "Blatt"
+    STUECK          = "Stück"
+
+class YesNo(Enum):
+    YES = "yes"
+    NO  = "no"
+
+class product_promotion_data(BaseModel):
+    """Collection of product and promotion data of an product advertisement."""
+    brand: str = Field(description="The brand associated with the product")
+    product_category: List[str] = Field(description="List of categories associated with the product.")
+    price: float = Field(description="The promotional price.")
+    regular_price: float = Field(default=None, description="The regular price of the promotion.")
+    relative_discount: int = Field(default=None, description="The relative discount of the promotion.")
+    absolute_discount: float = Field(default=None, description="The absolute discount of the promotion.")
+    GTINs: List[str] = Field(description="List of the GTINs for the products.")
+    weight_number: float = Field(description="Only the numerical weight specication.")
+    weight_unit: WeightUnit = Field(description="Only the weight unit.")
+    # weight_unit: Literal["Gramm", "Kilogramm", "Milliliter", "Liter", "Waschladungen", "Blatt", "Stück"] = Field(description="Only the weight unit.")
+    different_types: YesNo = Field(description="If promotion offer different sorts.")
+    # different_types: Literal["yes", "no"] = Field(description="If promotion offer different sorts.")
+
+######################################################################
+######################################################################
+
+def convert_items_to_strings(prediction):
+    if isinstance(prediction, str):
+        return prediction
+    elif isinstance(prediction, list):
+        return ', '.join(prediction)
+    else:
+        return str(prediction)
+
+def get_output_results(dict_output, dict_result):
+    for key, value in dict_output.items():
+        if key == 'brand':
+            dict_result['brand'] = convert_items_to_strings(dict_output['brand'])
+        elif key == 'product_category':
+            dict_result['product_category'] = convert_items_to_strings(dict_output['product_category'])
+        elif key == 'price':
+            dict_result['price'] = convert_items_to_strings(dict_output['price'])
+        elif key == 'regular_price':
+            dict_result['regular_price'] = convert_items_to_strings(dict_output['regular_price'])
+        elif key == 'relative_discount':
+            dict_result['relative_discount'] = convert_items_to_strings(dict_output['relative_discount'])
+        elif key == 'absolute_discount':
+            dict_result['absolute_discount'] = convert_items_to_strings(dict_output['absolute_discount'])
+        elif key == 'GTINs':
+            dict_result['GTINs'] = convert_items_to_strings(dict_output['GTINs'])
+        elif key == 'weight_number':
+            dict_result['weight_number'] = convert_items_to_strings(dict_output['weight_number'])
+        elif key == 'weight_unit':
+            dict_result['weight_unit'] = convert_items_to_strings(dict_output['weight_unit'])
+        elif key == 'different_types':
+            dict_result['different_types'] = convert_items_to_strings(dict_output['different_types'])
+    return dict_result
+
+def get_openai_client(key, model_name):
+    # usage OpenAI
+    client = langchain_openai.ChatOpenAI(
+        api_key     = key,
+        model       = model_name, 
+        temperature = VLM_TEMPERATURE,
+    )
+    
+    # usage Google
+    # client = langchain_google_genai.ChatGoogleGenerativeAI(
+    #     api_key     = key,
+    #     model       = model_name, 
+    #     temperature = VLM_TEMPERATURE,
+    # )
+
+    print(client)
+    client = client.with_structured_output(product_promotion_data, include_raw=True)
+    os.environ["GOOGLE_USED_MODEL"] = model_name
+    return client
+
+def prompt(query_image, task, dict_log):
+    system_message = "You are an assistant for question-answering tasks."
+    dict_log['system_message'] = system_message
+
+    human_message_text = "Do the user-provided task on the input image. \
+    The answer must be provided in JSON format. \
+    The task is: " + task + ".\
+    If there is no information of a target, return NaN." 
+    dict_log['human_message_text'] = human_message_text
+
+    human_messages = [
+        {
+            "type": "text",
+            "text": human_message_text
+        },
+        {
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{query_image}"},
+        },
+    ]
+    return dict_log, [SystemMessage(content=system_message), HumanMessage(content=human_messages)]
+
+def do_request(client, query_image_base64, task, dict_log, dict_result, dict_result_cost):
+    dict_log, messages = prompt(query_image_base64, task, dict_log)
+
+    try:
+        start_time = time.time()
+        while True:
+            try:
+                response = client.invoke(messages)
+            except:
+                print("FAILED")
+                continue
+            break
+        elapsed_time = time.time() - start_time
+        dict_result_cost['elapsed_time_[s]'] = float("{:.2f}".format(elapsed_time))
+
+        if response['parsed']:
+            dict_result = get_output_results(response['parsed'].dict(), dict_result)
+        dict_result_cost = token_price_evaluation(response['raw'], dict_result_cost)
+    
+    except openai.BadRequestError as e:
+        print(f"BadRequestError: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except openai.ContentFilterFinishReasonError as e:
+        print(f"ContentFilterFinishReasonError: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except ConnectionError as e:
+        print(f"Connection error occurred: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except requests.exceptions.RequestException as e:
+        print(f"An error occurred: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except ValueError as ve:
+        print(f"Validation error: {ve}")
+        return dict_log, dict_result, dict_result_cost
+    except httpx.HTTPStatusError as e:
+        print(f"HTTPStatusError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+    except openai.RateLimitError as e:
+        print(f"RateLimitError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+    except openai.InternalServerError as e:
+        print(f"InternalServerError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+
+    return dict_log, dict_result, dict_result_cost
+
+# https://ai.google.dev/gemini-api/docs/pricing
+# https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/
+def token_price_evaluation(response, dict_result_cost):
+    PRICING = {
+        "gpt-4-0-mini": {"input": 0.165 / 1000000, "output": 0.66 / 1000000},
+        "gemini-2.0-flash": {"input": 0.10 / 1000000, "output": 0.40 / 1000000},
+        "gemini-2.5-flash": {"input": 0.30 / 1000000, "output": 2.50 / 1000000},
+    }
+    MODEL = os.environ["GOOGLE_USED_MODEL"]
+
+    # usage OpenAI
+    token_usage     = response.response_metadata.get("token_usage", {})
+    input_tokens    = token_usage.get("prompt_tokens", 0)
+    output_tokens   = token_usage.get("completion_tokens", 0)
+    total_tokens    = token_usage.get("total_tokens", input_tokens + output_tokens)
+
+    # usage Google
+    # token_usage     = response.usage_metadata
+    # input_tokens    = token_usage.get("input_tokens", 0)
+    # output_tokens   = token_usage.get("output_tokens", 0)
+    # reasoning_tokens= token_usage.get("output_token_details", {}).get("reasoning", 0)
+    # total_tokens    = token_usage.get("total_tokens", input_tokens + output_tokens)
+
+    input_cost  = input_tokens * PRICING[MODEL]["input"]
+    output_cost = output_tokens * PRICING[MODEL]["output"]
+    total_cost  = input_cost + output_cost
+
+    print(f"Model Used: {MODEL}")
+    print(f"Input Tokens: {input_tokens}, Cost: ${input_cost:.4f}")
+    print(f"Output Tokens: {output_tokens}, Cost: ${output_cost:.4f}")
+    # print(f"Reasoning Tokens: {reasoning_tokens}")
+    print(f"Total Tokens: {total_tokens}")
+    print(f"Total Cost: ${total_cost:.4f}")
+    print('*'*30)
+
+    dict_result_cost['input_tokens'] = input_tokens
+    dict_result_cost['output_tokens'] = output_tokens
+    # dict_result_cost['reasoning_tokens'] = reasoning_tokens
+    dict_result_cost['total_tokens'] = total_tokens
+    dict_result_cost['total_cost'] = float(total_cost)
+
+    return dict_result_cost

code/vlm/use_vlm_ollama.py

@@ -0,0 +1,140 @@
+import httpx
+import json
+import requests
+import time
+
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing_extensions import List
+from typing import Literal
+
+from requests.exceptions import ConnectionError
+
+VLM_TEMPERATURE         = 0
+######################################################################
+######################################################################
+
+class WeightUnit(Enum):
+    GRAMM           = "Gramm"
+    KILOGRAM        = "Kilogramm"
+    MILLILITER      = "Milliliter"
+    LITER           = "Liter"
+    WASCHLADUNGEN   = "Waschladungen"
+    BLATT           = "Blatt"
+    STUECK          = "Stück"
+
+class YesNo(Enum):
+    YES = "yes"
+    NO  = "no"
+
+class product_promotion_data(BaseModel):
+    """Collection of product and promotion data of an product advertisement."""
+    brand: str = Field(description="The brand associated with the product")
+    product_category: List[str] = Field(description="List of categories associated with the product.")
+    price: float = Field(description="The promotional price.")
+    regular_price: float = Field(default=None, description="The regular price of the promotion.")
+    relative_discount: int = Field(default=None, description="The relative discount of the promotion.")
+    absolute_discount: float = Field(default=None, description="The absolute discount of the promotion.")
+    GTINs: List[str] = Field(description="List of the GTINs for the products.")
+    # weight_number: float = Field(description="Only the numerical weight specication.")
+    weight_unit: WeightUnit = Field(description="Only the weight unit.")
+    # weight_unit: Literal["Gramm", "Kilogramm", "Milliliter", "Liter", "Waschladungen", "Blatt", "Stück"] = Field(description="Only the weight unit.")
+    different_types: YesNo = Field(description="If promotion offer different sorts.")
+    # different_types: Literal["yes", "no"] = Field(description="If promotion offer different sorts.")
+
+######################################################################
+######################################################################
+
+def convert_items_to_strings(prediction):
+    if isinstance(prediction, str):
+        return prediction
+    elif isinstance(prediction, list):
+        return ', '.join(prediction)
+    else:
+        return str(prediction)
+
+def get_output_results(dict_output, dict_result):
+    for key, value in dict_output.items():
+        if key == 'brand':
+            dict_result['brand'] = convert_items_to_strings(dict_output['brand'])
+        elif key == 'product_category':
+            dict_result['product_category'] = convert_items_to_strings(dict_output['product_category'])
+        elif key == 'price':
+            dict_result['price'] = convert_items_to_strings(dict_output['price'])
+        elif key == 'regular_price':
+            dict_result['regular_price'] = convert_items_to_strings(dict_output['regular_price'])
+        elif key == 'relative_discount':
+            dict_result['relative_discount'] = convert_items_to_strings(dict_output['relative_discount'])
+        elif key == 'absolute_discount':
+            dict_result['absolute_discount'] = convert_items_to_strings(dict_output['absolute_discount'])
+        elif key == 'GTINs':
+            dict_result['GTINs'] = convert_items_to_strings(dict_output['GTINs'])
+        elif key == 'weight_number':
+            dict_result['weight_number'] = convert_items_to_strings(dict_output['weight_number'])
+        elif key == 'weight_unit':
+            dict_result['weight_unit'] = convert_items_to_strings(dict_output['weight_unit'])
+        elif key == 'different_types':
+            dict_result['different_types'] = convert_items_to_strings(dict_output['different_types'])
+    return dict_result
+
+def do_request(ip_address, in_model_name, query_image_base64, task, dict_log, dict_result, dict_result_cost):
+    system_message = "You are an assistant for question-answering tasks."
+    human_message_text  = "Do the user-provided task on the input image. \
+    The answer must be provided in JSON format. \
+    The task is: " + task + ".\
+    If there is no information of a target, return NaN."
+
+    dict_log['system_message'] = system_message
+    dict_log['human_message_text'] = human_message_text
+
+    try:
+        start_time = time.time()
+        response = requests.post(
+            "requests-url",
+            json={
+                "model": in_model_name,
+                "prompt": human_message_text,
+                "system": system_message,
+                "stream": False,
+                "images": [query_image_base64],
+                "options": {
+                    "temperature": VLM_TEMPERATURE
+                },
+                "format": product_promotion_data.model_json_schema()
+            },
+            timeout=60
+        )
+        print(response)
+        elapsed_time = time.time() - start_time
+        dict_result_cost['elapsed_time_[s]'] = float("{:.2f}".format(elapsed_time))
+
+        parsed = json.loads(response.text)
+        print(parsed['response'])
+        
+        if parsed['response']:
+            dict_result = get_output_results(json.loads(parsed['response']), dict_result)
+            print('dict_result')
+            print(dict_result)
+
+    except requests.exceptions.RequestException as e:
+        print(f"Request failed: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except requests.Timeout as e:
+        print(f"Request failed: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except ValueError as ve:
+        print(f"Validation error: {ve}")
+        return dict_log, dict_result, dict_result_cost
+    except httpx.HTTPStatusError as e:
+        print(f"HTTPStatusError: {e}")
+        time.sleep(60)
+        return dict_log, dict_result, dict_result_cost
+    except KeyError as e:
+        print(f"Key error: {e}")
+        return dict_log, dict_result, dict_result_cost
+    except ConnectionError as e:
+        print(f"Connection error occurred: {e}")
+        return dict_log, dict_result, dict_result_cost
+    
+
+    return dict_log, dict_result, dict_result_cost