import os import sys import yaml import argparse import pandas as pd import numpy as np import joblib from sklearn.metrics import f1_score sys.path.append(os.path.dirname(os.path.abspath(__file__))) from models import SOTAStackingDetector def load_config(config_path): with open(config_path, "r", encoding="utf-8") as f: return yaml.safe_load(f) def get_local_explanation(model_key, model, X_scaled, feature_names): """Calculates local explanations (which features pushed the prediction towards AI or Human).""" if "logistic_regression" in model_key or "hybrid" in model_key: coefs = model.coef_[0] # Slice X_scaled to match the length of coefs if model only provides partial coefficients num_coefs = len(coefs) X_scaled_subset = X_scaled[:, :num_coefs] # Contribution is scaled value * coefficient contributions = X_scaled_subset * coefs top_ai_idx = np.argmax(contributions, axis=1) top_human_idx = np.argmin(contributions, axis=1) top_ai_feats = [feature_names[idx] for idx in top_ai_idx] top_human_feats = [feature_names[idx] for idx in top_human_idx] return top_ai_feats, top_human_feats else: # Fallback for non-linear models like XGBoost # Return global top features as placeholder return ["global_importance"] * X_scaled.shape[0], ["global_importance"] * X_scaled.shape[0] def main(): parser = argparse.ArgumentParser(description="Run inference on recent debates to detect potential AI content.") parser.add_argument("--config", default="configs/config.yaml", help="Path to config file") args = parser.parse_args() config = load_config(args.config) processed_dir = config["paths"]["processed_dir"] models_dir = config["paths"]["models_dir"] output_dir = config["paths"]["output_dir"] os.makedirs(output_dir, exist_ok=True) # 1. Load Model Package model_pkg_path = os.path.join(models_dir, "best_detector.pkl") if not os.path.exists(model_pkg_path): print(f"Error: Trained model package not found at {model_pkg_path}. Please run train_detector.py first.") sys.exit(1) pkg = joblib.load(model_pkg_path) model = pkg["model"] model_key = pkg["model_key"] model_name = pkg["model_name"] scalers = pkg["scalers"] print(f"Loaded best model: {model_name} ({model_key})") # 2. Load Processed Recent Debates recent_path = os.path.join(processed_dir, "recent_features.csv") if not os.path.exists(recent_path): print(f"Error: Processed recent debates features not found at {recent_path}. Please run build_features.py first.") sys.exit(1) df_recent = pd.read_csv(recent_path) print(f"Loaded {len(df_recent)} recent speeches for inference.") # Determine columns to use if model_key == "logistic_regression_sty": cols_to_use = pkg["stylometric_cols"] scaler = scalers["sty"] elif model_key == "logistic_regression_ng": cols_to_use = pkg["ngram_cols"] scaler = None elif model_key == "xgb_sty": cols_to_use = pkg["stylometric_cols"] scaler = None elif model_key == "hybrid": cols_to_use = pkg["hybrid_cols"] scaler = scalers["hybrid"] else: raise ValueError(f"Unknown model key {model_key}") # Prepare features X = df_recent[cols_to_use].values if scaler is not None: X_scaled = scaler.transform(X) else: X_scaled = X # 3. Predict Probabilities and Classes print("Running model inference...") prob_ai = model.predict_proba(X_scaled)[:, 1] predictions = model.predict(X_scaled) # Calculate custom scores prob_human = 1.0 - prob_ai confidence = 2.0 * np.abs(prob_ai - 0.5) # 0 (uncertain) to 1 (highly certain) # Add to dataframe df_recent["prob_ai"] = prob_ai df_recent["prob_human"] = prob_human df_recent["prediction"] = predictions df_recent["confidence_score"] = confidence # 4. Get local explanations # Load vectorizers to map n-gram index back to text if needed word_vectorizer = joblib.load(pkg["vectorizer_words_path"]) char_vectorizer = joblib.load(pkg["vectorizer_chars_path"]) friendly_feature_names = [] for f in cols_to_use: if f.startswith("ngram_word_"): idx = int(f.split("_")[-1]) friendly_feature_names.append(f"Word n-gram: '{word_vectorizer.get_feature_names_out()[idx]}'") elif f.startswith("ngram_char_"): idx = int(f.split("_")[-1]) friendly_feature_names.append(f"Char n-gram: '{char_vectorizer.get_feature_names_out()[idx]}'") else: friendly_feature_names.append(f) top_ai_feats, top_human_feats = get_local_explanation(model_key, model, X_scaled, friendly_feature_names) df_recent["explanation_top_ai_feature"] = top_ai_feats df_recent["explanation_top_human_feature"] = top_human_feats # Save raw predictions predictions_path = os.path.join(output_dir, "recent_debates_predictions.csv") # Save essential columns first, and we can include text too cols_to_save = [ "date", "speaker", "party", "chamber", "document_type", "legislature", "prob_ai", "prob_human", "confidence_score", "prediction", "explanation_top_ai_feature", "explanation_top_human_feature" ] if "actual_label" in df_recent.columns: cols_to_save.append("actual_label") if "ai_model" in df_recent.columns: cols_to_save.append("ai_model") df_recent_out = df_recent[cols_to_save + ["text"]] df_recent_out.to_csv(predictions_path, index=False) print(f"Saved inference predictions to {predictions_path}") # 5. Aggregate Analysis df_recent["date_dt"] = pd.to_datetime(df_recent["date"]) df_recent["year"] = df_recent["date_dt"].dt.year df_recent["week"] = df_recent["date_dt"] - pd.to_timedelta(df_recent["date_dt"].dt.weekday, unit='D') print("\n--- Aggregating suspicion scores ---") # Year year_stats = df_recent.groupby("year")["prob_ai"].agg(["count", "mean", "std"]).reset_index() year_stats.columns = ["year", "speech_count", "mean_ai_suspicion", "std_ai_suspicion"] year_stats.to_csv(os.path.join(output_dir, "stats_by_year.csv"), index=False) print("\nSuspicion Score by Year (recent period):") print(year_stats.to_string(index=False)) # Week week_stats = df_recent.groupby("week")["prob_ai"].agg(["count", "mean", "std"]).reset_index() week_stats.columns = ["week", "speech_count", "mean_ai_suspicion", "std_ai_suspicion"] week_stats = week_stats.sort_values(by="week") week_stats_save = week_stats.copy() week_stats_save["week"] = week_stats_save["week"].dt.strftime("%Y-%m-%d") week_stats_save.to_csv(os.path.join(output_dir, "stats_by_week.csv"), index=False) print(f"\nSaved weekly aggregated suspicion scores to {os.path.join(output_dir, 'stats_by_week.csv')} ({len(week_stats)} weeks)") # Speaker (Deputy) deputy_stats = df_recent.groupby("speaker")["prob_ai"].agg(["count", "mean", "std"]).reset_index() deputy_stats.columns = ["speaker", "speech_count", "mean_ai_suspicion", "std_ai_suspicion"] deputy_stats = deputy_stats.sort_values(by="mean_ai_suspicion", ascending=False) deputy_stats.to_csv(os.path.join(output_dir, "stats_by_deputy.csv"), index=False) print("\nTop 5 Deputies by AI Suspicion Score:") print(deputy_stats.head(5).to_string(index=False)) # Political Group (Party) party_stats = df_recent.groupby("party")["prob_ai"].agg(["count", "mean", "std"]).reset_index() party_stats.columns = ["party", "speech_count", "mean_ai_suspicion", "std_ai_suspicion"] party_stats = party_stats.sort_values(by="mean_ai_suspicion", ascending=False) party_stats.to_csv(os.path.join(output_dir, "stats_by_party.csv"), index=False) print("\nSuspicion Score by Political Party:") print(party_stats.to_string(index=False)) # Document Type doc_stats = df_recent.groupby("document_type")["prob_ai"].agg(["count", "mean", "std"]).reset_index() doc_stats.columns = ["document_type", "speech_count", "mean_ai_suspicion", "std_ai_suspicion"] doc_stats = doc_stats.sort_values(by="mean_ai_suspicion", ascending=False) doc_stats.to_csv(os.path.join(output_dir, "stats_by_doc_type.csv"), index=False) print("\nSuspicion Score by Document Type:") print(doc_stats.to_string(index=False)) # If we have actual labels, let's report the accuracy of recent detection if "actual_label" in df_recent.columns: actuals = df_recent["actual_label"].values acc = (predictions == actuals).mean() f1 = f1_score(actuals, predictions, zero_division=0) print(f"\nInference evaluation against ground-truth labels:") print(f"Accuracy: {acc:.4f} | F1-Score: {f1:.4f}") print("\nInference step completed successfully.") if __name__ == "__main__": main()