feat: Phase 3 - baseline and XLM-R fine-tuning

data/tokenized/absa_cls_dataset/dataset_dict.json

@@ -0,0 +1 @@
+{"splits": ["train", "validation", "test"]}

data/tokenized/absa_cls_dataset/test/data-00000-of-00001.arrow

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

data/tokenized/absa_cls_dataset/test/dataset_info.json

@@ -0,0 +1,26 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "label": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "input_ids": {
+      "feature": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "attention_mask": {
+      "feature": {
+        "dtype": "int8",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

data/tokenized/absa_cls_dataset/test/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "b686d9c13fd54a9d",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

data/tokenized/absa_cls_dataset/train/data-00000-of-00001.arrow

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

data/tokenized/absa_cls_dataset/train/dataset_info.json

@@ -0,0 +1,26 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "label": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "input_ids": {
+      "feature": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "attention_mask": {
+      "feature": {
+        "dtype": "int8",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

data/tokenized/absa_cls_dataset/train/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "59c1808a1a0be248",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

data/tokenized/absa_cls_dataset/validation/data-00000-of-00001.arrow

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

data/tokenized/absa_cls_dataset/validation/dataset_info.json

@@ -0,0 +1,26 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "label": {
+      "dtype": "int64",
+      "_type": "Value"
+    },
+    "input_ids": {
+      "feature": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "attention_mask": {
+      "feature": {
+        "dtype": "int8",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

data/tokenized/absa_cls_dataset/validation/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "a33b9cfd2402e633",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

data/tokenized/absa_ner_dataset/dataset_dict.json

@@ -0,0 +1 @@
+{"splits": ["train", "validation", "test"]}

data/tokenized/absa_ner_dataset/test/data-00000-of-00001.arrow

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

data/tokenized/absa_ner_dataset/test/dataset_info.json

@@ -0,0 +1,29 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "input_ids": {
+      "feature": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "attention_mask": {
+      "feature": {
+        "dtype": "int8",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "labels": {
+      "feature": {
+        "dtype": "int64",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

data/tokenized/absa_ner_dataset/test/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "0fa99b895566c7b5",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

data/tokenized/absa_ner_dataset/train/data-00000-of-00001.arrow

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

data/tokenized/absa_ner_dataset/train/dataset_info.json

@@ -0,0 +1,29 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "input_ids": {
+      "feature": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "attention_mask": {
+      "feature": {
+        "dtype": "int8",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "labels": {
+      "feature": {
+        "dtype": "int64",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

data/tokenized/absa_ner_dataset/train/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "535b22b0ddf3661d",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

data/tokenized/absa_ner_dataset/validation/data-00000-of-00001.arrow

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

data/tokenized/absa_ner_dataset/validation/dataset_info.json

@@ -0,0 +1,29 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "input_ids": {
+      "feature": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "attention_mask": {
+      "feature": {
+        "dtype": "int8",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    },
+    "labels": {
+      "feature": {
+        "dtype": "int64",
+        "_type": "Value"
+      },
+      "_type": "Sequence"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

data/tokenized/absa_ner_dataset/validation/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "caedb7425c742cc1",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

mlruns/1/f7e324a252a94812b0d4158371276cb0/artifacts/confusion_matrix.json

@@ -0,0 +1,28 @@
+{
+  "confusion_matrix": [
+    [
+      246,
+      26,
+      31,
+      13
+    ],
+    [
+      14,
+      120,
+      26,
+      7
+    ],
+    [
+      20,
+      29,
+      60,
+      1
+    ],
+    [
+      3,
+      7,
+      0,
+      3
+    ]
+  ]
+}

notebooks/03_model_comparison.ipynb

@@ -0,0 +1,101 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Model Comparison\n",
+        "\n",
+        "This notebook connects to the MLflow tracking server and compares the results of our models.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "import mlflow\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "import json\n",
+        "\n",
+        "mlflow.set_tracking_uri('sqlite:///mlflow/mlflow.db')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Load all runs\n",
+        "experiment = mlflow.get_experiment_by_name('multilingual-absa')\n",
+        "df = mlflow.search_runs(experiment_ids=[experiment.experiment_id])\n",
+        "display(df.head())\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Bar chart: macro-F1 comparison\n",
+        "metrics = df[['tags.mlflow.runName', 'metrics.eval_macro_f1', 'metrics.test_f1', 'metrics.test_macro_f1', 'metrics.hindi_zero_shot_macro_f1']].fillna(0)\n",
+        "metrics['Best F1'] = metrics[['metrics.eval_macro_f1', 'metrics.test_f1', 'metrics.test_macro_f1']].max(axis=1)\n",
+        "\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "sns.barplot(data=metrics, x='tags.mlflow.runName', y='Best F1')\n",
+        "plt.title('Model Comparison by Macro-F1 / Span-F1')\n",
+        "plt.xticks(rotation=45)\n",
+        "plt.show()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Load confusion matrix for best sentiment classifier\n",
+        "# Note: Assuming the confusion_matrix.json artifact was downloaded or parsed.\n",
+        "print('Confusion Matrix (Placeholder for artifact loading)')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# 5 Example Predictions\n",
+        "print('Example 1: The food was great but service was slow.')\n",
+        "print('Example 2: El sistema operativo es muy estable.')\n",
+        "print('... (Load pipeline and infer here)')\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.11.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}

notebooks/03_train_colab.ipynb

@@ -0,0 +1,128 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Google Colab Training Notebook\n",
+        "\n",
+        "This notebook is intended to be run on Google Colab with a T4 GPU. It clones the repo, installs dependencies, and runs the training scripts.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "!git clone https://github.com/Aryanmishra-dev/Multilingual-Absa.git\n",
+        "%cd Multilingual-Absa\n",
+        "!pip install -r requirements.txt\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Mount Google Drive to save models and MLflow logs persistently\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Create symlinks or copy data if needed\n",
+        "# Assuming data is in the repo for now\n",
+        "!mkdir -p /content/drive/MyDrive/ABSA_models\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Prepare dataset\n",
+        "!PYTHONPATH=. python src/data/hf_dataset.py\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Run Aspect Extraction Training\n",
+        "!PYTHONPATH=. python src/models/train_aspect_extraction.py\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Run Sentiment Classification Training\n",
+        "!PYTHONPATH=. python src/models/train_sentiment.py\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Run Baseline as well\n",
+        "!PYTHONPATH=. python src/models/baseline.py\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Cross-lingual Evaluation\n",
+        "!PYTHONPATH=. python src/evaluation/cross_lingual_eval.py\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# Copy models back to Drive\n",
+        "!cp -r models/* /content/drive/MyDrive/ABSA_models/\n",
+        "!cp -r mlflow /content/drive/MyDrive/ABSA_models/\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.11.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 4
+}

scripts/generate_notebooks.py

@@ -0,0 +1,73 @@
+import json
+from pathlib import Path
+
+def create_notebook(filename: str, cells_content: list):
+    cells = []
+    for content, cell_type in cells_content:
+        cells.append({
+            "cell_type": cell_type,
+            "metadata": {},
+            "execution_count": None if cell_type == "code" else None,
+            "outputs": [] if cell_type == "code" else None,
+            "source": [line + "\n" for line in content.split("\n")]
+        })
+        
+        # Clean up outputs/execution_count for markdown
+        if cell_type == "markdown":
+            del cells[-1]["execution_count"]
+            del cells[-1]["outputs"]
+
+    notebook = {
+        "cells": cells,
+        "metadata": {
+            "kernelspec": {
+                "display_name": "Python 3",
+                "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.11.0"
+            }
+        },
+        "nbformat": 4,
+        "nbformat_minor": 4
+    }
+    
+    Path("notebooks").mkdir(parents=True, exist_ok=True)
+    with open(f"notebooks/{filename}", "w") as f:
+        json.dump(notebook, f, indent=2)
+
+def main():
+    colab_cells = [
+        ("# Google Colab Training Notebook\n\nThis notebook is intended to be run on Google Colab with a T4 GPU. It clones the repo, installs dependencies, and runs the training scripts.", "markdown"),
+        ("!git clone https://github.com/Aryanmishra-dev/Multilingual-Absa.git\n%cd Multilingual-Absa\n!pip install -r requirements.txt", "code"),
+        ("# Mount Google Drive to save models and MLflow logs persistently\nfrom google.colab import drive\ndrive.mount('/content/drive')", "code"),
+        ("# Create symlinks or copy data if needed\n# Assuming data is in the repo for now\n!mkdir -p /content/drive/MyDrive/ABSA_models", "code"),
+        ("# Prepare dataset\n!PYTHONPATH=. python src/data/hf_dataset.py", "code"),
+        ("# Run Aspect Extraction Training\n!PYTHONPATH=. python src/models/train_aspect_extraction.py", "code"),
+        ("# Run Sentiment Classification Training\n!PYTHONPATH=. python src/models/train_sentiment.py", "code"),
+        ("# Run Baseline as well\n!PYTHONPATH=. python src/models/baseline.py", "code"),
+        ("# Cross-lingual Evaluation\n!PYTHONPATH=. python src/evaluation/cross_lingual_eval.py", "code"),
+        ("# Copy models back to Drive\n!cp -r models/* /content/drive/MyDrive/ABSA_models/\n!cp -r mlflow /content/drive/MyDrive/ABSA_models/", "code")
+    ]
+    
+    comparison_cells = [
+        ("# Model Comparison\n\nThis notebook connects to the MLflow tracking server and compares the results of our models.", "markdown"),
+        ("import mlflow\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport json\n\nmlflow.set_tracking_uri('sqlite:///mlflow/mlflow.db')", "code"),
+        ("# Load all runs\nexperiment = mlflow.get_experiment_by_name('multilingual-absa')\ndf = mlflow.search_runs(experiment_ids=[experiment.experiment_id])\ndisplay(df.head())", "code"),
+        ("# Bar chart: macro-F1 comparison\nmetrics = df[['tags.mlflow.runName', 'metrics.eval_macro_f1', 'metrics.test_f1', 'metrics.test_macro_f1', 'metrics.hindi_zero_shot_macro_f1']].fillna(0)\nmetrics['Best F1'] = metrics[['metrics.eval_macro_f1', 'metrics.test_f1', 'metrics.test_macro_f1']].max(axis=1)\n\nplt.figure(figsize=(10, 6))\nsns.barplot(data=metrics, x='tags.mlflow.runName', y='Best F1')\nplt.title('Model Comparison by Macro-F1 / Span-F1')\nplt.xticks(rotation=45)\nplt.show()", "code"),
+        ("# Load confusion matrix for best sentiment classifier\n# Note: Assuming the confusion_matrix.json artifact was downloaded or parsed.\nprint('Confusion Matrix (Placeholder for artifact loading)')", "code"),
+        ("# 5 Example Predictions\nprint('Example 1: The food was great but service was slow.')\nprint('Example 2: El sistema operativo es muy estable.')\nprint('... (Load pipeline and infer here)')", "code")
+    ]
+    
+    create_notebook("03_train_colab.ipynb", colab_cells)
+    create_notebook("03_model_comparison.ipynb", comparison_cells)
+
+if __name__ == '__main__':
+    main()

scripts/mlflow_ui.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Script to launch MLflow UI
+# Use sqlite backend as specified
+
+# Ensure the directory exists
+mkdir -p mlflow
+
+echo "Starting MLflow UI with SQLite backend..."
+echo "Access the UI at http://localhost:5000"
+mlflow ui --backend-store-uri sqlite:///mlflow/mlflow.db --host 0.0.0.0 --port 5000

src/data/bio_tagger.py

@@ -0,0 +1,97 @@
+import re
+from typing import List, Dict, Any, Tuple
+
+def tokenize(text: str) -> List[Tuple[str, int, int]]:
+    """
+    Tokenizes text by words, returning tokens and their start/end character offsets.
+    Uses simple regex based tokenization to preserve whitespace semantics for BIO tagging.
+    """
+    tokens = []
+    # Match non-whitespace characters
+    for match in re.finditer(r'\S+', text):
+        tokens.append((match.group(), match.start(), match.end()))
+    return tokens
+
+def convert_to_bio(text: str, aspect_terms: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Converts text and aspect spans to BIO tagged tokens.
+    
+    Args:
+        text: The input review string.
+        aspect_terms: List of dictionaries with 'term', 'from', and 'to' keys.
+        
+    Returns:
+        List of dictionaries with 'token' and 'label' (B-ASP, I-ASP, O).
+    """
+    tokens = tokenize(text)
+    
+    # Sort aspects by start index
+    sorted_aspects = sorted(aspect_terms, key=lambda x: x['from'])
+    
+    bio_tags = []
+    aspect_idx = 0
+    num_aspects = len(sorted_aspects)
+    
+    for token_str, t_start, t_end in tokens:
+        label = "O"
+        
+        # Move aspect pointer if we've passed the current aspect completely
+        while aspect_idx < num_aspects and sorted_aspects[aspect_idx]['to'] <= t_start:
+            aspect_idx += 1
+            
+        if aspect_idx < num_aspects:
+            curr_aspect = sorted_aspects[aspect_idx]
+            a_start = curr_aspect['from']
+            a_end = curr_aspect['to']
+            
+            # Check overlap
+            if not (t_end <= a_start or t_start >= a_end):
+                # There is overlap
+                # If this token overlaps with the start of the aspect
+                if t_start <= a_start or (len(bio_tags) > 0 and bio_tags[-1]['label'] == "O" and t_start > a_start):
+                     label = "B-ASP"
+                else:
+                     # Check if previous tag was B-ASP or I-ASP for the *same* aspect
+                     if len(bio_tags) > 0 and bio_tags[-1]['label'] in ("B-ASP", "I-ASP"):
+                         label = "I-ASP"
+                     else:
+                         label = "B-ASP"
+                         
+        bio_tags.append({"token": token_str, "label": label})
+        
+    return bio_tags
+
+def bio_to_aspects(tokens: List[str], labels: List[str]) -> List[str]:
+    """
+    Converts BIO tags back to a list of aspect terms.
+    
+    Args:
+        tokens: List of string tokens.
+        labels: List of BIO labels corresponding to the tokens.
+        
+    Returns:
+        List of extracted aspect term strings.
+    """
+    aspects = []
+    current_aspect = []
+    
+    for token, label in zip(tokens, labels):
+        if label == "B-ASP":
+            if current_aspect:
+                aspects.append(" ".join(current_aspect))
+            current_aspect = [token]
+        elif label == "I-ASP":
+            if current_aspect:
+                current_aspect.append(token)
+            else:
+                # Invalid sequence (I-ASP without B-ASP), treat as B-ASP
+                current_aspect = [token]
+        else: # O
+            if current_aspect:
+                aspects.append(" ".join(current_aspect))
+                current_aspect = []
+                
+    if current_aspect:
+        aspects.append(" ".join(current_aspect))
+        
+    return aspects

src/data/hf_dataset.py

@@ -0,0 +1,156 @@
+import json
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from typing import List, Dict, Any, Tuple
+from datasets import Dataset, DatasetDict
+from transformers import AutoTokenizer
+from sklearn.model_selection import train_test_split
+from src.data.bio_tagger import convert_to_bio
+
+np.random.seed(42)
+
+def load_data(file_paths: List[Path]) -> List[Dict[str, Any]]:
+    data = []
+    for path in file_paths:
+        with open(path, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.strip():
+                    data.append(json.loads(line))
+    return data
+
+def prepare_ner_data(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Prepares data for Token Classification (NER)."""
+    ner_data = []
+    label_map = {"O": 0, "B-ASP": 1, "I-ASP": 2}
+    
+    for item in data:
+        text = item['text']
+        aspects = item.get('aspect_terms', [])
+        bio_tags = convert_to_bio(text, aspects)
+        
+        tokens = [t['token'] for t in bio_tags]
+        ner_tags = [label_map[t['label']] for t in bio_tags]
+        
+        ner_data.append({
+            "tokens": tokens,
+            "ner_tags": ner_tags,
+            "id": item.get("id", str(len(ner_data)))
+        })
+    return ner_data
+
+def prepare_cls_data(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Prepares data for Sequence Classification (Sentiment)."""
+    cls_data = []
+    sentiment_map = {"positive": 0, "negative": 1, "neutral": 2, "conflict": 3}
+    
+    for item in data:
+        text = item['text']
+        aspects = item.get('aspect_terms', [])
+        
+        for aspect in aspects:
+            term = aspect['term']
+            polarity = aspect['polarity']
+            
+            if polarity not in sentiment_map:
+                continue
+                
+            cls_data.append({
+                "text": text,
+                "aspect_term": term,
+                "label": sentiment_map[polarity],
+                "id": f"{item.get('id', str(len(cls_data)))}_{term}"
+            })
+    return cls_data
+
+def align_labels_with_tokens(labels, word_ids):
+    new_labels = []
+    current_word = None
+    for word_id in word_ids:
+        if word_id is None:
+            new_labels.append(-100)
+        elif word_id != current_word:
+            new_labels.append(labels[word_id])
+            current_word = word_id
+        else:
+            new_labels.append(-100)
+    return new_labels
+
+def main():
+    data_dir = Path("data/processed")
+    output_dir = Path("data/tokenized")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Load all English SemEval data
+    train_path = data_dir / "semeval_train.jsonl"
+    test_path = data_dir / "semeval_test.jsonl"
+    all_data = load_data([train_path, test_path])
+    
+    # Prepare datasets
+    ner_data = prepare_ner_data(all_data)
+    cls_data = prepare_cls_data(all_data)
+    
+    tokenizer = AutoTokenizer.from_pretrained("xlm-roberta-base")
+    
+    # ---------------------------------------------------------
+    # 1. Token Classification (NER) Dataset
+    # ---------------------------------------------------------
+    ner_df = pd.DataFrame(ner_data)
+    
+    # Split 80/10/10
+    # For NER, we don't have a single sentiment to stratify on easily, so random split
+    train_ner, temp_ner = train_test_split(ner_df, test_size=0.2, random_state=42)
+    val_ner, test_ner = train_test_split(temp_ner, test_size=0.5, random_state=42)
+    
+    def tokenize_and_align_labels(examples):
+        tokenized_inputs = tokenizer(
+            examples["tokens"], truncation=True, is_split_into_words=True, max_length=128
+        )
+        labels = []
+        for i, label in enumerate(examples[f"ner_tags"]):
+            word_ids = tokenized_inputs.word_ids(batch_index=i)
+            labels.append(align_labels_with_tokens(label, word_ids))
+        tokenized_inputs["labels"] = labels
+        return tokenized_inputs
+        
+    ner_dataset = DatasetDict({
+        "train": Dataset.from_pandas(train_ner, preserve_index=False),
+        "validation": Dataset.from_pandas(val_ner, preserve_index=False),
+        "test": Dataset.from_pandas(test_ner, preserve_index=False),
+    })
+    
+    tokenized_ner = ner_dataset.map(tokenize_and_align_labels, batched=True, remove_columns=["tokens", "ner_tags", "id"])
+    tokenized_ner.save_to_disk(str(output_dir / "absa_ner_dataset"))
+    print(f"NER Dataset saved to {output_dir / 'absa_ner_dataset'}")
+    
+    # ---------------------------------------------------------
+    # 2. Sequence Classification (Sentiment) Dataset
+    # ---------------------------------------------------------
+    cls_df = pd.DataFrame(cls_data)
+    
+    # Stratified split 80/10/10 based on label
+    train_cls, temp_cls = train_test_split(cls_df, test_size=0.2, random_state=42, stratify=cls_df['label'])
+    val_cls, test_cls = train_test_split(temp_cls, test_size=0.5, random_state=42, stratify=temp_cls['label'])
+    
+    def tokenize_cls(examples):
+        # Format: [CLS] text [SEP] aspect_term [SEP]
+        return tokenizer(
+            examples["text"],
+            examples["aspect_term"],
+            truncation=True,
+            max_length=128,
+            padding=False
+        )
+        
+    cls_dataset = DatasetDict({
+        "train": Dataset.from_pandas(train_cls, preserve_index=False),
+        "validation": Dataset.from_pandas(val_cls, preserve_index=False),
+        "test": Dataset.from_pandas(test_cls, preserve_index=False),
+    })
+    
+    tokenized_cls = cls_dataset.map(tokenize_cls, batched=True, remove_columns=["text", "aspect_term", "id"])
+    tokenized_cls.save_to_disk(str(output_dir / "absa_cls_dataset"))
+    print(f"CLS Dataset saved to {output_dir / 'absa_cls_dataset'}")
+
+if __name__ == "__main__":
+    main()

src/evaluation/cross_lingual_eval.py

@@ -0,0 +1,114 @@
+import os
+import json
+import torch
+import numpy as np
+from pathlib import Path
+from transformers import (
+    AutoTokenizer,
+    AutoModelForTokenClassification,
+    AutoModelForSequenceClassification,
+    pipeline
+)
+from sklearn.metrics import f1_score
+import mlflow
+
+from src.training.mlflow_utils import setup_mlflow
+from src.data.bio_tagger import bio_to_aspects
+
+def load_data(file_path: Path):
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            if line.strip():
+                data.append(json.loads(line))
+    return data
+
+def main():
+    setup_mlflow()
+    
+    # Check if models exist (might not if trained on Colab)
+    aspect_model_path = Path("models/aspect_extraction/best")
+    sentiment_model_path = Path("models/sentiment/best")
+    
+    if not aspect_model_path.exists() or not sentiment_model_path.exists():
+        print("Models not found locally. Skipping cross-lingual evaluation until models are trained.")
+        return
+        
+    print("Loading models...")
+    tokenizer = AutoTokenizer.from_pretrained("xlm-roberta-base")
+    
+    aspect_model = AutoModelForTokenClassification.from_pretrained(str(aspect_model_path))
+    sentiment_model = AutoModelForSequenceClassification.from_pretrained(str(sentiment_model_path))
+    
+    device = 0 if torch.cuda.is_available() else -1
+    
+    ner_pipeline = pipeline("token-classification", model=aspect_model, tokenizer=tokenizer, device=device, aggregation_strategy="simple")
+    
+    # Load Hindi Data
+    hindi_path = Path("data/processed/amazon_hindi.jsonl")
+    hindi_data = load_data(hindi_path)
+    
+    print(f"Evaluating zero-shot on {len(hindi_data)} Hindi samples...")
+    
+    sentiment_map_rev = {0: "positive", 1: "negative", 2: "neutral", 3: "conflict"}
+    sentiment_map = {"positive": 0, "negative": 1, "neutral": 2, "conflict": 3}
+    
+    true_labels = []
+    pred_labels = []
+    
+    for item in hindi_data:
+        text = item["text"]
+        aspects = item.get("aspect_terms", [])
+        
+        for aspect in aspects:
+            term = aspect["term"]
+            true_polarity = aspect["polarity"]
+            if true_polarity not in sentiment_map:
+                continue
+                
+            true_labels.append(sentiment_map[true_polarity])
+            
+            # Inference Sentiment
+            inputs = tokenizer(text, term, return_tensors="pt", truncation=True, max_length=128)
+            if device == 0:
+                inputs = {k: v.to("cuda") for k, v in inputs.items()}
+                sentiment_model.to("cuda")
+                
+            with torch.no_grad():
+                logits = sentiment_model(**inputs).logits
+                pred_idx = torch.argmax(logits, dim=1).item()
+                
+            pred_labels.append(pred_idx)
+            
+    hindi_macro_f1 = f1_score(true_labels, pred_labels, average="macro") if len(true_labels) > 0 else 0.0
+    print(f"Hindi Zero-Shot Macro-F1: {hindi_macro_f1}")
+    
+    # We retrieve the best English test score from MLflow
+    # For now, let's just log the cross lingual gap if we know English F1
+    client = mlflow.tracking.MlflowClient()
+    experiment = client.get_experiment_by_name("multilingual-absa")
+    
+    en_macro_f1 = 0.0
+    if experiment:
+        runs = client.search_runs(
+            experiment_ids=[experiment.experiment_id],
+            filter_string="metrics.test_macro_f1 > 0",
+            max_results=1,
+            order_by=["metrics.test_macro_f1 DESC"]
+        )
+        if runs:
+            en_macro_f1 = runs[0].data.metrics.get("test_macro_f1", 0.0)
+            
+    print(f"Best English Test Macro-F1: {en_macro_f1}")
+    gap = en_macro_f1 - hindi_macro_f1
+    print(f"Cross-Lingual Gap: {gap}")
+    
+    with mlflow.start_run(run_name="cross_lingual_eval"):
+        mlflow.log_metrics({
+            "hindi_zero_shot_macro_f1": float(hindi_macro_f1),
+            "english_test_macro_f1": float(en_macro_f1),
+            "cross_lingual_gap": float(gap)
+        })
+
+if __name__ == "__main__":
+    main()

src/training/mlflow_utils.py

@@ -0,0 +1,73 @@
+import mlflow
+from typing import Dict, Any, Optional
+from pathlib import Path
+import os
+
+# Default configuration
+MLFLOW_TRACKING_URI = "sqlite:///mlflow/mlflow.db"
+EXPERIMENT_NAME = "multilingual-absa"
+
+def setup_mlflow():
+    """Initializes MLflow tracking URI and experiment."""
+    # Ensure the directory exists
+    Path("mlflow").mkdir(parents=True, exist_ok=True)
+    
+    mlflow.set_tracking_uri(MLFLOW_TRACKING_URI)
+    mlflow.set_experiment(EXPERIMENT_NAME)
+
+def log_training_run(params: Dict[str, Any], metrics: Dict[str, float], model_path: Optional[str | Path] = None, run_name: Optional[str] = None) -> str:
+    """
+    Logs parameters, metrics, and optionally a model artifact to MLflow.
+    
+    Args:
+        params: Dictionary of hyperparameters or configuration.
+        metrics: Dictionary of evaluation metrics.
+        model_path: Path to the saved model directory or file.
+        run_name: Optional name for the run.
+        
+    Returns:
+        The ID of the created MLflow run.
+    """
+    setup_mlflow()
+    
+    with mlflow.start_run(run_name=run_name) as run:
+        mlflow.log_params(params)
+        mlflow.log_metrics(metrics)
+        
+        if model_path:
+            model_path_obj = Path(model_path)
+            if model_path_obj.exists():
+                mlflow.log_artifact(str(model_path_obj), artifact_path="model")
+            else:
+                print(f"Warning: Model path {model_path} does not exist. Artifact not logged.")
+                
+        return run.info.run_id
+
+def get_best_run(metric: str = "eval_macro_f1", ascending: bool = False) -> Optional[mlflow.entities.Run]:
+    """
+    Retrieves the best run from the experiment based on a specific metric.
+    
+    Args:
+        metric: The metric to sort by.
+        ascending: True if a lower metric is better (e.g., loss), False for higher is better (e.g., F1).
+        
+    Returns:
+        The MLflow Run object for the best run, or None if no runs exist.
+    """
+    setup_mlflow()
+    
+    experiment = mlflow.get_experiment_by_name(EXPERIMENT_NAME)
+    if not experiment:
+        return None
+        
+    runs = mlflow.search_runs(
+        experiment_ids=[experiment.experiment_id],
+        order_by=[f"metrics.{metric} {'ASC' if ascending else 'DESC'}"],
+        max_results=1,
+        output_format="list"
+    )
+    
+    if not runs:
+        return None
+        
+    return runs[0]

tests/test_bio_tagger.py

@@ -0,0 +1,51 @@
+import pytest
+from src.data.bio_tagger import convert_to_bio, bio_to_aspects
+
+def test_single_aspect():
+    text = "The food was amazing."
+    aspects = [{"term": "food", "from": 4, "to": 8}]
+    tags = convert_to_bio(text, aspects)
+    
+    assert [t['token'] for t in tags] == ["The", "food", "was", "amazing."]
+    assert [t['label'] for t in tags] == ["O", "B-ASP", "O", "O"]
+
+def test_multiple_aspects():
+    text = "The food was good, but the service was terrible."
+    aspects = [
+        {"term": "food", "from": 4, "to": 8},
+        {"term": "service", "from": 27, "to": 34}
+    ]
+    tags = convert_to_bio(text, aspects)
+    
+    expected_labels = ["O", "B-ASP", "O", "O", "O", "O", "B-ASP", "O", "O"]
+    assert [t['label'] for t in tags] == expected_labels
+
+def test_no_aspects():
+    text = "Everything was fine."
+    aspects = []
+    tags = convert_to_bio(text, aspects)
+    
+    assert all(t['label'] == "O" for t in tags)
+
+def test_multi_word_aspect():
+    text = "The operating system is very stable."
+    aspects = [{"term": "operating system", "from": 4, "to": 20}]
+    tags = convert_to_bio(text, aspects)
+    
+    assert [t['label'] for t in tags] == ["O", "B-ASP", "I-ASP", "O", "O", "O"]
+
+def test_adjacent_aspects():
+    text = "Great battery life." # Suppose battery and life are separate
+    aspects = [
+        {"term": "battery", "from": 6, "to": 13},
+        {"term": "life.", "from": 14, "to": 19}
+    ]
+    tags = convert_to_bio(text, aspects)
+    assert [t['label'] for t in tags] == ["O", "B-ASP", "B-ASP"]
+    
+def test_bio_to_aspects():
+    tokens = ["The", "operating", "system", "and", "battery", "life", "are", "great"]
+    labels = ["O", "B-ASP", "I-ASP", "O", "B-ASP", "B-ASP", "O", "O"]
+    
+    extracted = bio_to_aspects(tokens, labels)
+    assert extracted == ["operating system", "battery", "life"]