Upload folder using huggingface_hub

src/multilingual_sentiment_analysis.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: multilingual_sentiment_analysis
+Version: 0.1.0
+Requires-Dist: transformers
+Requires-Dist: datasets
+Requires-Dist: torch
+Requires-Dist: gradio
+Dynamic: requires-dist

src/multilingual_sentiment_analysis.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+src/multilingual_sentiment_analysis/__init__.py
+src/multilingual_sentiment_analysis/config.py
+src/multilingual_sentiment_analysis/evaluate.py
+src/multilingual_sentiment_analysis/infer.py
+src/multilingual_sentiment_analysis/preprocess.py
+src/multilingual_sentiment_analysis/train.py
+src/multilingual_sentiment_analysis.egg-info/PKG-INFO
+src/multilingual_sentiment_analysis.egg-info/SOURCES.txt
+src/multilingual_sentiment_analysis.egg-info/dependency_links.txt
+src/multilingual_sentiment_analysis.egg-info/requires.txt
+src/multilingual_sentiment_analysis.egg-info/top_level.txt
+tests/test_app.py
+tests/test_preprocess.py

src/multilingual_sentiment_analysis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/multilingual_sentiment_analysis.egg-info/requires.txt

@@ -0,0 +1,4 @@
+transformers
+datasets
+torch
+gradio

src/multilingual_sentiment_analysis.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+app
+multilingual_sentiment_analysis

src/multilingual_sentiment_analysis/config.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+DATA_DIR = PROJECT_ROOT / "data"
+AIRLINE_DATA_DIR = DATA_DIR / "airline_tweets"
+MULTILINGUAL_DATA_DIR = DATA_DIR / "multilingual"
+AIRLINE_RESULTS_DIR = PROJECT_ROOT / "results" / "airline_tweets"
+RESULTS_DIR = PROJECT_ROOT / "results" / "multilingual"
+AIRLINE_MODEL_DIR = PROJECT_ROOT / "sentiment_model" / "airline-tweets-sentiment-model"
+MODEL_DIR = PROJECT_ROOT / "sentiment_model" / "general-multilingual-sentiment-model"
+
+MODEL_CHECKPOINT = "xlm-roberta-base"
+LABEL2ID = {"negative": 0, "neutral": 1, "positive": 2}
+ID2LABEL = {value: key for key, value in LABEL2ID.items()}
+MAX_LENGTH = 128
+DATASET_NAME = "cardiffnlp/tweet_sentiment_multilingual"
+LANGUAGES = ("arabic", "english", "french", "german", "hindi", "italian", "portuguese", "spanish")

src/multilingual_sentiment_analysis/evaluate.py

@@ -0,0 +1,89 @@
+"""Evaluate a saved sentiment model and produce plots."""
+
+import argparse
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from datasets import load_from_disk
+from sklearn.metrics import classification_report, confusion_matrix
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
+
+from .config import ID2LABEL, MODEL_DIR, MULTILINGUAL_DATA_DIR, RESULTS_DIR
+
+
+def evaluate(model_dir: Path, test_dataset: Path, output_dir: Path, show: bool = False) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    model = AutoModelForSequenceClassification.from_pretrained(model_dir)
+    tokenizer = AutoTokenizer.from_pretrained(model_dir)
+    trainer = Trainer(
+        model=model,
+        args=TrainingArguments(output_dir=str(output_dir), use_cpu=True, report_to="none"),
+        processing_class=tokenizer,
+    )
+    dataset = load_from_disk(str(test_dataset))
+    if "language" not in dataset.column_names:
+        raise ValueError("The test dataset must include a language column for per-language evaluation.")
+    predictions = trainer.predict(dataset)
+    y_true = predictions.label_ids
+    y_pred = np.argmax(predictions.predictions, axis=-1)
+    labels = list(sorted(ID2LABEL))
+    names = [ID2LABEL[label] for label in labels]
+    report = classification_report(y_true, y_pred, labels=labels, target_names=names, zero_division=0, output_dict=True)
+    print(classification_report(y_true, y_pred, labels=labels, target_names=names, zero_division=0))
+    per_language = {}
+    languages = np.array(dataset["language"])
+    for language in sorted(set(languages)):
+        mask = languages == language
+        per_language[language] = classification_report(
+            y_true[mask], y_pred[mask], labels=labels, target_names=names, zero_division=0, output_dict=True
+        )
+    with (output_dir / "metrics.json").open("w", encoding="utf-8") as file:
+        json.dump({"overall": report, "per_language": per_language}, file, ensure_ascii=False, indent=2)
+    cm = confusion_matrix(y_true, y_pred, labels=labels)
+
+    plt.figure(figsize=(6, 5))
+    sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=names, yticklabels=names)
+    plt.xlabel("Predicted label")
+    plt.ylabel("True label")
+    plt.title("Confusion Matrix — Test Set")
+    plt.tight_layout()
+    plt.savefig(output_dir / "confusion_matrix.png", dpi=150)
+
+    state_path = model_dir / "trainer_state.json"
+    if state_path.exists():
+        with state_path.open(encoding="utf-8") as file:
+            history = json.load(file).get("log_history", [])
+        train = [(entry["step"], entry["loss"]) for entry in history if "loss" in entry]
+        validation = [(entry["step"], entry["eval_loss"]) for entry in history if "eval_loss" in entry]
+        if train or validation:
+            plt.figure(figsize=(7, 4))
+            if train:
+                plt.plot(*zip(*train), label="Training loss")
+            if validation:
+                plt.plot(*zip(*validation), label="Validation loss")
+            plt.xlabel("Step")
+            plt.ylabel("Loss")
+            plt.title("Training vs. Validation Loss")
+            plt.legend()
+            plt.tight_layout()
+            plt.savefig(output_dir / "loss_curve.png", dpi=150)
+    if show:
+        plt.show()
+    plt.close("all")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Evaluate a saved sentiment model.")
+    parser.add_argument("--model-dir", type=Path, default=MODEL_DIR)
+    parser.add_argument("--test-dataset", type=Path, default=MULTILINGUAL_DATA_DIR / "test_dataset")
+    parser.add_argument("--output-dir", type=Path, default=RESULTS_DIR / "eval")
+    parser.add_argument("--show", action="store_true")
+    args = parser.parse_args()
+    evaluate(args.model_dir, args.test_dataset, args.output_dir, args.show)
+
+
+if __name__ == "__main__":
+    main()

src/multilingual_sentiment_analysis/infer.py

@@ -0,0 +1,62 @@
+"""Inference helpers for the saved sentiment model."""
+
+import os
+from functools import lru_cache
+from pathlib import Path
+
+import torch
+from transformers import pipeline
+
+from .config import MODEL_DIR
+
+
+def resolve_model_path() -> str:
+    """Return an explicitly configured Hub/local model or the local default."""
+    configured = os.environ.get("SENTIMENT_MODEL_PATH")
+    if configured:
+        model_path = Path(configured).expanduser()
+        if model_path.is_dir():
+            return str(model_path)
+        if not model_path.is_absolute() and "/" in configured:
+            return configured  # Hugging Face model ID, e.g. username/model-name
+        raise FileNotFoundError(f"Configured SENTIMENT_MODEL_PATH does not exist: {model_path}")
+
+    model_path = MODEL_DIR
+    if not model_path.is_dir():
+        raise FileNotFoundError(
+            f"No fine-tuned model found at {model_path}. Train one with `python -m multilingual_sentiment_analysis.train` "
+            "or set SENTIMENT_MODEL_PATH to a compatible model directory."
+        )
+    return str(model_path)
+
+
+@lru_cache(maxsize=1)
+def get_classifier():
+    use_gpu = os.environ.get("USE_GPU", "false").lower() == "true"
+    if use_gpu and not torch.cuda.is_available():
+        raise RuntimeError("USE_GPU=true but CUDA is not available.")
+    return pipeline(
+        "sentiment-analysis", model=resolve_model_path(), tokenizer=resolve_model_path(),
+        device=0 if use_gpu else -1,
+    )
+
+
+def predict(text: str) -> dict[str, float | str]:
+    if not isinstance(text, str) or not text.strip():
+        raise ValueError("Input must be a non-empty string.")
+    result = get_classifier()(text.strip())[0]
+    return {"label": result["label"], "confidence": float(result["score"])}
+
+
+def predict_batch(texts: list[str]) -> list[dict[str, float | str]]:
+    if not isinstance(texts, list) or not texts or any(not isinstance(text, str) or not text.strip() for text in texts):
+        raise ValueError("Input must be a non-empty list of non-empty strings.")
+    return [
+        {"label": result["label"], "confidence": float(result["score"])}
+        for result in get_classifier()([text.strip() for text in texts])
+    ]
+
+
+if __name__ == "__main__":
+    for sample in ("The flight was delayed three hours.", "Merci, le vol était très agréable !", "الخدمة كانت ممتازة"):
+        print(f"{sample}\n  -> {predict(sample)}\n")

src/multilingual_sentiment_analysis/preprocess.py

@@ -0,0 +1,60 @@
+"""Prepare Cardiff NLP's multilingual tweet-sentiment dataset for fine-tuning."""
+
+import argparse
+import re
+from pathlib import Path
+
+from datasets import DatasetDict, concatenate_datasets, load_dataset
+from transformers import AutoTokenizer
+
+from .config import DATASET_NAME, LANGUAGES, MAX_LENGTH, MODEL_CHECKPOINT, MULTILINGUAL_DATA_DIR
+
+
+def clean_text(text: str) -> str:
+    """Remove tweet metadata while preserving Unicode text, emojis, and accents."""
+    text = str(text).lower()
+    text = re.sub(r"https?://\S+|www\.\S+", "", text)
+    text = re.sub(r"@\w+", "", text)
+    text = text.replace("#", "")
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def load_multilingual_splits(dataset_name: str = DATASET_NAME) -> DatasetDict:
+    """Load official splits and retain each row's language for later evaluation.
+
+    The dataset's ``all`` configuration merges languages but does not expose their
+    provenance. Loading each official configuration retains that information.
+    """
+    grouped = {"train": [], "validation": [], "test": []}
+    for language in LANGUAGES:
+        dataset = load_dataset(dataset_name, language)
+        for split in grouped:
+            grouped[split].append(dataset[split].add_column("language", [language] * len(dataset[split])))
+    return DatasetDict({split: concatenate_datasets(parts).shuffle(seed=42) for split, parts in grouped.items()})
+
+
+def build_datasets(output_dir: Path, checkpoint: str = MODEL_CHECKPOINT) -> None:
+    tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+    def tokenize(batch):
+        return tokenizer(batch["text"], truncation=True, max_length=MAX_LENGTH)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    datasets = load_multilingual_splits()
+    for split, dataset in datasets.items():
+        cleaned = dataset.map(lambda row: {"text": clean_text(row["text"])})
+        cleaned.filter(lambda row: bool(row["text"])).map(tokenize, batched=True).save_to_disk(
+            str(output_dir / f"{split.replace('validation', 'val')}_dataset")
+        )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Download and prepare multilingual tweet-sentiment data.")
+    parser.add_argument("--output-dir", type=Path, default=MULTILINGUAL_DATA_DIR)
+    parser.add_argument("--checkpoint", default=MODEL_CHECKPOINT)
+    args = parser.parse_args()
+    build_datasets(args.output_dir, args.checkpoint)
+
+
+if __name__ == "__main__":
+    main()

src/multilingual_sentiment_analysis/train.py

@@ -0,0 +1,66 @@
+"""Fine-tune the sentiment model."""
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+from datasets import load_from_disk
+from sklearn.metrics import accuracy_score, f1_score
+from transformers import (
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    DataCollatorWithPadding,
+    Trainer,
+    TrainingArguments,
+    set_seed,
+)
+
+from .config import ID2LABEL, LABEL2ID, MODEL_CHECKPOINT, MODEL_DIR, MULTILINGUAL_DATA_DIR, RESULTS_DIR
+
+
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    return {
+        "accuracy": accuracy_score(labels, predictions),
+        "f1": f1_score(labels, predictions, average="weighted"),
+    }
+
+
+def train(data_dir: Path, output_dir: Path, model_dir: Path, checkpoint: str, epochs: float, use_cpu: bool) -> None:
+    set_seed(42)
+    tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+    model = AutoModelForSequenceClassification.from_pretrained(
+        checkpoint, num_labels=len(LABEL2ID), id2label=ID2LABEL, label2id=LABEL2ID
+    )
+    args = TrainingArguments(
+        output_dir=str(output_dir), eval_strategy="epoch", save_strategy="epoch",
+        learning_rate=2e-5, per_device_train_batch_size=16, per_device_eval_batch_size=32,
+        num_train_epochs=epochs, weight_decay=0.01, load_best_model_at_end=True,
+        metric_for_best_model="f1", logging_steps=50, report_to="none", use_cpu=use_cpu,
+    )
+    trainer = Trainer(
+        model=model, args=args, train_dataset=load_from_disk(str(data_dir / "train_dataset")),
+        eval_dataset=load_from_disk(str(data_dir / "val_dataset")),
+        data_collator=DataCollatorWithPadding(tokenizer=tokenizer), processing_class=tokenizer,
+        compute_metrics=compute_metrics,
+    )
+    trainer.train()
+    trainer.save_model(str(model_dir))
+    tokenizer.save_pretrained(str(model_dir))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Fine-tune XLM-R sentiment classification.")
+    parser.add_argument("--data-dir", type=Path, default=MULTILINGUAL_DATA_DIR)
+    parser.add_argument("--output-dir", type=Path, default=RESULTS_DIR)
+    parser.add_argument("--model-dir", type=Path, default=MODEL_DIR)
+    parser.add_argument("--checkpoint", default=MODEL_CHECKPOINT)
+    parser.add_argument("--epochs", type=float, default=3)
+    parser.add_argument("--cpu", action="store_true", help="Force CPU training.")
+    args = parser.parse_args()
+    train(args.data_dir, args.output_dir, args.model_dir, args.checkpoint, args.epochs, args.cpu)
+
+
+if __name__ == "__main__":
+    main()