Fix VADER Sentiment's Negative Bias in Gold Market Analysis

from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
import pandas as pd
import numpy as np

# Personal note: Learned after my model lost $12K in paper trading
analyzer = SentimentIntensityAnalyzer()

def get_vader_scores(text):
    """Extract compound score from VADER"""
    scores = analyzer.polarity_scores(text)
    return scores['compound']

# Load your gold market news
df = pd.read_csv('gold_news.csv')
df['vader_score'] = df['headline'].apply(get_vader_scores)

# Compare to human labels (assuming you have them)
# Watch out: VADER uses -1 to +1, adjust your labels to match
df['human_label'] = df['human_sentiment'].map({
    'negative': -1, 'neutral': 0, 'positive': 1
})

# Calculate bias metrics
bias = df['vader_score'].mean() - df['human_label'].mean()
print(f"Mean bias: {bias:.3f}")
print(f"Negative over-weighting: {(df['vader_score'] < -0.05).sum()} vs human: {(df['human_label'] < 0).sum()}")

from sklearn.linear_model import LinearRegression
from scipy.stats import percentileofscore

class VADERCalibrator:
    """Calibrates VADER scores to match domain-specific sentiment"""
    
    def __init__(self):
        self.calibrator = LinearRegression()
        self.fitted = False
    
    def fit(self, vader_scores, true_labels):
        """
        Personal note: Tried polynomial regression first,
        but linear works better for gold market text
        """
        X = np.array(vader_scores).reshape(-1, 1)
        y = np.array(true_labels)
        
        self.calibrator.fit(X, y)
        self.fitted = True
        
        # Store calibration stats for monitoring
        self.slope = self.calibrator.coef_[0]
        self.intercept = self.calibrator.intercept_
        
        print(f"Calibration: y = {self.slope:.3f}x + {self.intercept:.3f}")
    
    def transform(self, vader_scores):
        """Apply calibration to new scores"""
        if not self.fitted:
            raise ValueError("Call fit() before transform()")
        
        X = np.array(vader_scores).reshape(-1, 1)
        calibrated = self.calibrator.predict(X)
        
        # Watch out: Clip to [-1, 1] range
        return np.clip(calibrated, -1, 1)

# Fit calibrator on your labeled data
calibrator = VADERCalibrator()
calibrator.fit(df['vader_score'], df['human_label'])

# Apply to all scores
df['calibrated_score'] = calibrator.transform(df['vader_score'])

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, confusion_matrix

# Split your data (I use 80/20)
train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)

# Fit on train only
train_calibrator = VADERCalibrator()
train_calibrator.fit(train_df['vader_score'], train_df['human_label'])

# Test on holdout
test_df['calibrated_score'] = train_calibrator.transform(test_df['vader_score'])

# Convert scores to labels for confusion matrix
def score_to_label(score, threshold=0.05):
    """Classify sentiment with dead zone for neutral"""
    if score > threshold:
        return 1
    elif score < -threshold:
        return -1
    return 0

test_df['vader_label'] = test_df['vader_score'].apply(score_to_label)
test_df['calibrated_label'] = test_df['calibrated_score'].apply(score_to_label)

# Compare errors
vader_mae = mean_absolute_error(test_df['human_label'], test_df['vader_label'])
calibrated_mae = mean_absolute_error(test_df['human_label'], test_df['calibrated_label'])

print(f"VADER MAE: {vader_mae:.3f}")
print(f"Calibrated MAE: {calibrated_mae:.3f}")
print(f"Improvement: {((vader_mae - calibrated_mae) / vader_mae * 100):.1f}%")

# Personal note: This caught overfitting twice before I adjusted my train/test split
print("\nConfusion Matrix (Calibrated):")
print(confusion_matrix(test_df['human_label'], test_df['calibrated_label']))

import json
from datetime import datetime

class ProductionVADERCalibrator:
    """Production wrapper with logging and drift detection"""
    
    def __init__(self, calibrator):
        self.calibrator = calibrator
        self.prediction_log = []
    
    def predict(self, text):
        """Score text and log for drift monitoring"""
        raw_score = analyzer.polarity_scores(text)['compound']
        calibrated = self.calibrator.transform([raw_score])[0]
        
        # Log prediction
        self.prediction_log.append({
            'timestamp': datetime.now().isoformat(),
            'raw_score': float(raw_score),
            'calibrated_score': float(calibrated),
            'text_preview': text[:100]
        })
        
        return calibrated
    
    def check_drift(self, window=100):
        """Alert if recent scores drift from training distribution"""
        if len(self.prediction_log) < window:
            return None
        
        recent = self.prediction_log[-window:]
        recent_mean = np.mean([p['calibrated_score'] for p in recent])
        
        # Watch out: Set drift threshold based on your training data
        if abs(recent_mean) > 0.15:  # My threshold from testing
            return f"DRIFT ALERT: Mean score {recent_mean:.3f} in last {window} predictions"
        return None
    
    def save_log(self, filepath):
        """Export predictions for retraining"""
        with open(filepath, 'w') as f:
            json.dump(self.prediction_log, f, indent=2)

# Deploy
prod_calibrator = ProductionVADERCalibrator(calibrator)

# Use in your pipeline
new_headline = "Gold prices steady amid mixed economic signals"
sentiment = prod_calibrator.predict(new_headline)
print(f"Calibrated sentiment: {sentiment:.3f}")

# Check for drift daily
drift_warning = prod_calibrator.check_drift()
if drift_warning:
    print(drift_warning)