Alternative Data and NLP in Quant Strategies › Building a News Sentiment Trading Signal

import numpy as np
import pandas as pd

# Simulate news feed data
np.random.seed(42)

# Generate synthetic news data for multiple stocks
tickers = ["AAPL", "GOOGL", "MSFT", "AMZN", "META"]
dates = pd.date_range(start="2023-01-01", end="2023-12-31", freq="B")

news_templates = {
    "positive": [
        "{ticker} beats earnings estimates, guidance raised",
        "{ticker} announces major partnership, shares surge",
        "{ticker} reports strong revenue growth in key segment",
        "Analysts upgrade {ticker} citing improved fundamentals",
        "{ticker} expands into new market with positive reception",
    ],
    "negative": [
        "{ticker} misses quarterly targets, cuts guidance",
        "{ticker} faces regulatory scrutiny over practices",
        "{ticker} reports declining margins amid competition",
        "Analysts downgrade {ticker} on execution concerns",
        "{ticker} announces restructuring and layoffs",
    ],
    "neutral": [
        "{ticker} reports results in line with expectations",
        "{ticker} maintains guidance for fiscal year",
        "{ticker} announces routine executive changes",
        "{ticker} schedules investor day presentation",
        "{ticker} completes previously announced acquisition",
    ],
}

# Generate news events
news_data = []
for date in dates:
    # Each day, 0-3 news items per stock
    for ticker in tickers:
        num_news = np.random.choice(
            [0, 0, 0, 1, 1, 2], p=[0.3, 0.2, 0.2, 0.15, 0.1, 0.05]
        )
        for _ in range(num_news):
            sentiment_type = np.random.choice(
                ["positive", "negative", "neutral"], p=[0.35, 0.35, 0.30]
            )
            template = np.random.choice(news_templates[sentiment_type])
            headline = template.format(ticker=ticker)

            news_data.append(
                {
                    "date": date,
                    "ticker": ticker,
                    "headline": headline,
                    "true_sentiment": sentiment_type,
                }
            )

news_df = pd.DataFrame(news_data)

def compute_sentiment_score(headline, model):
    """Convert headline to numerical sentiment score."""
    probs = model.analyze(headline)
    # Score: positive minus negative (ranges from -1 to +1)
    return probs["positive"] - probs["negative"]


# Apply sentiment analysis to all headlines
news_df["sentiment_score"] = news_df["headline"].apply(
    lambda x: compute_sentiment_score(x, finbert)
)

# Aggregate to daily sentiment per stock
daily_sentiment = (
    news_df.groupby(["date", "ticker"])
    .agg({"sentiment_score": ["mean", "count", "std"]})
    .reset_index()
)

# Flatten column names
daily_sentiment.columns = [
    "date",
    "ticker",
    "avg_sentiment",
    "news_count",
    "sentiment_std",
]
daily_sentiment["sentiment_std"] = daily_sentiment["sentiment_std"].fillna(0)


# Create sentiment signal with decay
def compute_signal_with_decay(df, halflife=5):
    """Compute exponentially weighted sentiment signal."""
    df = df.sort_values("date")

    # Fill missing dates with zero sentiment
    full_dates = pd.date_range(df["date"].min(), df["date"].max(), freq="B")
    df = (
        df.set_index("date")
        .reindex(full_dates)
        .fillna({"avg_sentiment": 0, "news_count": 0})
    )

    # Exponential decay weighting, alpha controls decay rate
    # With halflife=5, signals decay by 50% after 5 days
    alpha = 1 - np.exp(-np.log(2) / halflife)
    df["signal"] = df["avg_sentiment"].ewm(alpha=alpha, adjust=False).mean()

    return df.reset_index().rename(columns={"index": "date"})


# Compute signals for each ticker
signals = []
for ticker in tickers:
    ticker_data = daily_sentiment[daily_sentiment["ticker"] == ticker].copy()
    ticker_signal = compute_signal_with_decay(ticker_data)
    ticker_signal["ticker"] = ticker
    signals.append(ticker_signal)

signal_df = pd.concat(signals, ignore_index=True)

import pandas as pd


def sentiment_to_weights(signal_df, date, method="zscore"):
    """Convert sentiment signals to portfolio weights."""
    # Get signals for the date
    current = signal_df[signal_df["date"] == date][["ticker", "signal"]].copy()

    if len(current) == 0:
        return None

    if method == "zscore":
        # Z-score normalization: long positive z-scores, short negative
        mean_signal = current["signal"].mean()
        std_signal = current["signal"].std()
        if std_signal > 0:
            current["zscore"] = (current["signal"] - mean_signal) / std_signal
        else:
            current["zscore"] = 0

        # Winsorize extreme values
        current["zscore"] = current["zscore"].clip(-3, 3)

        # Convert to weights (equal notional exposure)
        total_abs = current["zscore"].abs().sum()
        if total_abs > 0:
            current["weight"] = current["zscore"] / total_abs
        else:
            current["weight"] = 0

    elif method == "rank":
        # Rank-based, simpler and more robust
        current["rank"] = current["signal"].rank()
        n = len(current)
        current["weight"] = (current["rank"] - (n + 1) / 2) / n

    return current[["ticker", "weight"]]


# Compute weights for a sample date
sample_date = pd.Timestamp("2023-06-15")
weights = sentiment_to_weights(signal_df, sample_date, method="zscore")