Add train and monitoring with tests

src/monitoring.py

@@ -0,0 +1,56 @@
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from datasets import load_from_disk
+from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
+import torch
+import numpy as np
+import json
+import os
+
+MODEL_PATH = "models/sentiment_model"
+TWEET_PATH = "data/processed/tweet_eval_tokenized"
+YT_PATH = "data/processed/youtube_comments"
+REPORTS_DIR = "reports"
+
+
+def evaluate_model(model, tokenizer, dataset, dataset_name, sample_size=300):
+    print(f"Valutazione su {dataset_name}")
+    subset = dataset["test"].select(range(min(sample_size, len(dataset["test"]))))
+
+    texts = subset["text"]
+    labels = subset["label"]
+
+    inputs = tokenizer(texts, truncation=True, padding=True, return_tensors="pt")
+    with torch.no_grad():
+        outputs = model(**inputs)
+        preds = torch.argmax(outputs.logits, dim=1).numpy()
+
+    acc = accuracy_score(labels, preds)
+    f1 = f1_score(labels, preds, average="weighted")
+    cm = confusion_matrix(labels, preds).tolist()
+
+    print(f"{dataset_name} — Accuracy: {acc:.3f}, F1: {f1:.3f}")
+    return {"dataset": dataset_name, "accuracy": acc, "f1": f1, "confusion_matrix": cm}
+
+def main():
+    print("Caricamento del modello")
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_PATH)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    model.eval()
+
+    tweet_ds = load_from_disk(TWEET_PATH)
+    youtube_ds = load_from_disk(YT_PATH)
+
+    tweet_metrics = evaluate_model(model, tokenizer, tweet_ds, "TweetEval")
+    youtube_metrics = evaluate_model(model, tokenizer, youtube_ds, "YouTube Comments")
+
+    os.makedirs(REPORTS_DIR, exist_ok=True)
+    metrics_path = os.path.join(REPORTS_DIR, "metrics.json")
+
+    results = {"TweetEval": tweet_metrics, "YouTube": youtube_metrics}
+    with open(metrics_path, "w") as f:
+        json.dump(results, f, indent=4)
+
+    print(f"Risultati salvati in: {metrics_path}")
+
+if __name__ == "__main__":
+    main()

src/train_model.py

@@ -0,0 +1,69 @@
+
+from transformers import (
+    AutoModelForSequenceClassification,
+    Trainer,
+    TrainingArguments,
+    AutoTokenizer
+)
+from datasets import load_from_disk
+import evaluate
+import numpy as np
+import os
+
+MODEL_NAME = "cardiffnlp/twitter-roberta-base-sentiment-latest"
+DATA_PATH = "data/processed/tweet_eval_tokenized"
+OUTPUT_DIR = "models/sentiment_model"
+
+def compute_metrics(eval_pred):
+    """Calcola metriche standard: accuracy e F1."""
+    metric_acc = evaluate.load("accuracy")
+    metric_f1 = evaluate.load("f1")
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    acc = metric_acc.compute(predictions=predictions, references=labels)
+    f1 = metric_f1.compute(predictions=predictions, references=labels, average="weighted")
+    return {"accuracy": acc["accuracy"], "f1": f1["f1"]}
+
+def train_model(sample_train_size=1000, sample_eval_size=300):
+    print("Caricamento dataset Tweet eval preprocessato")
+    dataset = load_from_disk(DATA_PATH)
+
+    # 
+    print(f"Riduzione dataset: {sample_train_size} per il train, {sample_eval_size} per la validazione.")
+    train_data = dataset["train"].select(range(min(sample_train_size, len(dataset["train"]))))
+    eval_data = dataset["validation"].select(range(min(sample_eval_size, len(dataset["validation"]))))
+
+   
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
+
+    # Parametri training
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        num_train_epochs=1,
+        per_device_train_batch_size=16,
+        per_device_eval_batch_size=32,
+        evaluation_strategy="epoch",
+        save_strategy="epoch",
+        logging_dir="./logs",
+        logging_steps=10,
+        load_best_model_at_end=True,
+        report_to="none", 
+    )
+
+    print("Avvio training")
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_data,
+        eval_dataset=eval_data,
+        compute_metrics=compute_metrics,
+    )
+
+    trainer.train()
+
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    trainer.save_model(OUTPUT_DIR)
+    print(f"Modello salvato in: {OUTPUT_DIR}")
+
+if __name__ == "__main__":
+    train_model()

tests/integration/test_monitoring.py

@@ -0,0 +1,24 @@
+import os
+import json
+import pytest
+from src.monitoring import monitor_model
+
+METRICS_PATH = "reports/metrics.json"
+
+@pytest.fixture(autouse=True)
+def cleanup_metrics():
+    """Pulisce file metrics prima del test."""
+    if os.path.exists(METRICS_PATH):
+        os.remove(METRICS_PATH)
+    yield
+    if os.path.exists(METRICS_PATH):
+        os.remove(METRICS_PATH)
+
+def test_monitoring_creates_metrics():
+    """Verifica che il monitoring crei il file metrics.json."""
+    monitor_model()
+    assert os.path.exists(METRICS_PATH), "metrics.json non è stato generato"
+
+    with open(METRICS_PATH, "r") as f:
+        metrics = json.load(f)
+    assert "accuracy" in metrics and "f1" in metrics, "Metriche principali mancanti"

tests/integration/test_train.py

@@ -0,0 +1,20 @@
+import os
+import shutil
+import pytest
+from src.train import train_model
+
+MODEL_DIR = "models/sentiment_model"
+
+@pytest.fixture(autouse=True)
+def cleanup():
+    if os.path.exists(MODEL_DIR):
+        shutil.rmtree(MODEL_DIR)
+    yield
+    if os.path.exists(MODEL_DIR):
+        shutil.rmtree(MODEL_DIR)
+
+def test_train_model_runs():
+    """Testa che il training parta e salvi un modello."""
+    train_model(sample_train_size=10, sample_eval_size=5) 
+    assert os.path.exists(MODEL_DIR), "La directory del modello non è stata creata"
+    assert os.path.exists(os.path.join(MODEL_DIR, "config.json")), "File config.json mancante"