Upload 10 files

training/__init__.py

@@ -0,0 +1,16 @@
+"""Shared training, evaluation and model-persistence logic."""
+
+from training.data_split import split_data
+from training.evaluation import evaluate_predictions, select_best_model
+from training.model_io import load_model, save_model
+from training.trainer import build_text_pipeline, train_and_evaluate_models
+
+__all__ = [
+    "build_text_pipeline",
+    "evaluate_predictions",
+    "load_model",
+    "save_model",
+    "select_best_model",
+    "split_data",
+    "train_and_evaluate_models",
+]

training/data_split.py

@@ -0,0 +1,14 @@
+"""Train/test split."""
+
+from sklearn.model_selection import train_test_split
+
+from config.constants import LABEL_COLUMN, RANDOM_STATE, TEST_SIZE, TEXT_COLUMN
+
+
+def split_data(df, text_column=TEXT_COLUMN, label_column=LABEL_COLUMN,
+               test_size=TEST_SIZE, random_state=RANDOM_STATE):
+    """Split the cleaned DataFrame into train/test text and labels."""
+    X = df[text_column]
+    y = df[label_column]
+    return train_test_split(X, y, test_size=test_size, shuffle=True,
+                            random_state=random_state)

training/evaluation.py

@@ -0,0 +1,27 @@
+"""Metrics computed for every trained model."""
+
+from sklearn.metrics import accuracy_score, classification_report
+
+
+def evaluate_predictions(y_test, y_pred):
+    """Return the weighted F1/precision/recall plus accuracy for one model."""
+    report = classification_report(y_test, y_pred, output_dict=True)
+    f1 = report['weighted avg']['f1-score']
+    precision = report['weighted avg']['precision']
+    recall = report['weighted avg']['recall']
+    accuracy = accuracy_score(y_test, y_pred)
+
+    return {
+        'F1 Score': f1,
+        'Precision': precision,
+        'Recall': recall,
+        'Accuracy': accuracy,
+    }
+
+
+def select_best_model(results_df):
+    """Return ``(best_model_name, best_model)`` - the row with the highest F1."""
+    best_model_name = results_df.loc[results_df['F1 Score'].idxmax(), 'Model']
+    best_model = results_df.loc[
+        results_df['Model'] == best_model_name, 'Trained Model'].values[0]
+    return best_model_name, best_model

training/model_io.py

@@ -0,0 +1,62 @@
+"""Saving and loading the trained pipeline."""
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import joblib
+
+from config.paths import ARTIFACTS_DIR, DEFAULT_MODEL_PATH
+
+#: Machine-readable summary of a training run, read by the web API.
+DEFAULT_METRICS_PATH = ARTIFACTS_DIR / "metrics.json"
+
+
+def save_model(model, path=DEFAULT_MODEL_PATH):
+    """Persist ``model`` with joblib"""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    joblib.dump(model, path)
+    return path
+
+
+def load_model(path=DEFAULT_MODEL_PATH):
+    """Load a pipeline previously saved by :func:`save_model`."""
+    return joblib.load(path)
+
+
+def save_metrics(results_df, best_model_name, path=DEFAULT_METRICS_PATH,
+                 dataset=None, plots=None):
+    """Write the run's scores to JSON so the web app can display them.
+
+    ``run_pipeline`` prints this table and then throws it away; the API needs it
+    to show which models were compared and which one won, without hardcoding
+    numbers in the front end.
+    """
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    scores = results_df.drop(columns=['Trained Model'])
+    models = [
+        {
+            'model': row['Model'],
+            'f1': float(row['F1 Score']),
+            'precision': float(row['Precision']),
+            'recall': float(row['Recall']),
+            'accuracy': float(row['Accuracy']),
+            'is_best': row['Model'] == best_model_name,
+        }
+        for _, row in scores.iterrows()
+    ]
+
+    payload = {
+        'best_model': best_model_name,
+        'selected_by': 'highest weighted F1 on the test set',
+        'generated_at': datetime.now(timezone.utc).isoformat(timespec='seconds'),
+        'dataset': dataset or {},
+        'models': models,
+        'plots': plots or {},
+    }
+
+    path.write_text(json.dumps(payload, indent=2), encoding='utf-8')
+    return path

training/trainer.py

@@ -0,0 +1,49 @@
+"""Training loop shared by all four classifiers."""
+
+import pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.pipeline import Pipeline
+
+from training.evaluation import evaluate_predictions, select_best_model
+
+
+def build_text_pipeline(model):
+    """Wrap ``model`` behind a ``TfidfVectorizer``."""
+    return Pipeline([('vect', TfidfVectorizer()),
+                     ('clf', model)])
+
+
+def train_and_evaluate_models(models, X_train, X_test, y_train, y_test):
+    """Train every model in ``models`` and compare them on the test set."""
+    results = []
+
+    for model_name, model in models.items():
+        # Create a text classification pipeline with TF-IDF vectorizer and the specified model
+        text_clf = build_text_pipeline(model)
+
+        # Train the model
+        text_clf.fit(X_train, y_train)
+
+        # Make predictions on the test set
+        y_pred = text_clf.predict(X_test)
+
+        # Evaluate the model
+        metrics = evaluate_predictions(y_test, y_pred)
+
+        # Store the results in a dictionary
+        result_dict = {
+            'Model': model_name,
+            'Trained Model': text_clf,  # Store the trained model
+            **metrics,
+        }
+
+        # Append the results to the list
+        results.append(result_dict)
+
+    # Convert the list of dictionaries to a DataFrame
+    results_df = pd.DataFrame(results)
+
+    # Find the best model based on the highest F1 Score
+    best_model_name, best_model = select_best_model(results_df)
+
+    return best_model_name, best_model, results_df