Chapter 41: Putting It All Together

"Strategy without tactics is the slowest route to victory. Tactics without strategy is the noise before defeat." --- Sun Tzu, The Art of War

Chapter Overview

Over the preceding forty chapters, you have built an extensive toolkit: probability theory and odds conversion (Part 1), statistical foundations and regression modeling (Part 2), machine learning and advanced modeling techniques (Parts 3--4), sport-specific analytical approaches (Part 5--6), bankroll management and risk control (Part 7), psychological discipline and behavioral awareness (Part 8), and industry knowledge and forward-looking perspective (Part 9).

Now it is time to integrate everything into a coherent, operational system.

This chapter is the first of two capstone chapters that bring the entire book together. Here, we address the practical question: How do you actually run a disciplined, profitable sports betting operation on a day-to-day and week-to-week basis? We will walk through the complete betting workflow from data collection to bet placement and review. We will show how to treat your bets as a diversified portfolio, managing risk across sports, markets, and timeframes. We will demonstrate how to combine multiple models and signals into a single, robust decision-making framework. We will build a performance attribution system that tells you exactly where your profits and losses are coming from. And we will discuss the principles of sustainable operation: how to keep learning, adapting, and scaling intelligently over time.

The difference between a good analyst and a profitable bettor is not just the quality of their models --- it is the quality of their process. This chapter is about process.

In this chapter, you will learn to: - Execute a systematic end-to-end betting workflow with clear stages, decision points, and feedback loops - Allocate risk capital across a diversified portfolio of betting opportunities using formal risk budgeting - Build ensemble systems that combine multiple models and signals for more robust decision-making - Implement performance attribution that decomposes P&L by sport, strategy, model, and time period

41.1 The Complete Betting Workflow

End-to-End Process Overview

A disciplined betting operation follows a systematic workflow that can be decomposed into distinct stages. Each stage has specific inputs, outputs, quality checks, and decision criteria. The complete workflow is:

Stage 1: Data Collection and Preparation
    |
    v
Stage 2: Feature Engineering and Model Training
    |
    v
Stage 3: Model Prediction and Signal Generation
    |
    v
Stage 4: Market Comparison and Edge Identification
    |
    v
Stage 5: Bet Sizing and Portfolio Construction
    |
    v
Stage 6: Bet Placement and Execution
    |
    v
Stage 7: Settlement and Record-Keeping
    |
    v
Stage 8: Performance Review and Model Update
    |
    (Feedback loop back to Stage 1)

Let us walk through each stage in detail.

Stage 1: Data Collection and Preparation

Every betting operation begins with data. The quality, completeness, and timeliness of your data directly constrain the quality of your models.

Data sources (as discussed in Chapter 5 and sport-specific chapters): - Historical game results and box scores - Play-by-play data and tracking data - Team and player statistics (traditional and advanced) - Injury reports, lineup information, and roster changes - Weather data for outdoor sports - Market data: opening and closing lines, line movement, betting percentages - Contextual data: scheduling, travel, rest days, rivalry games

Data preparation pipeline:

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

class BettingDataPipeline:
    """
    End-to-end data pipeline for sports betting analysis.
    Collects, cleans, and prepares data for modeling.
    """

    def __init__(self, sport, season):
        self.sport = sport
        self.season = season
        self.raw_data = {}
        self.clean_data = {}
        self.features = None

    def collect_data(self, sources):
        """
        Collect data from multiple sources.

        Parameters
        ----------
        sources : dict
            Mapping of source names to data retrieval functions.
        """
        for source_name, retrieval_func in sources.items():
            try:
                self.raw_data[source_name] = retrieval_func(
                    self.sport, self.season
                )
                print(f"Collected {source_name}: "
                      f"{len(self.raw_data[source_name])} records")
            except Exception as e:
                print(f"Error collecting {source_name}: {e}")

    def clean_data_source(self, source_name, cleaning_func):
        """Apply cleaning function to a specific data source."""
        if source_name in self.raw_data:
            self.clean_data[source_name] = cleaning_func(
                self.raw_data[source_name]
            )

    def merge_sources(self, merge_config):
        """
        Merge cleaned data sources into a single analysis-ready dataset.

        Parameters
        ----------
        merge_config : list of dict
            Each dict specifies left, right, keys, and how for a merge.
        """
        result = None
        for config in merge_config:
            left = self.clean_data[config['left']]
            right = self.clean_data[config['right']]
            if result is None:
                result = pd.merge(
                    left, right,
                    on=config['keys'],
                    how=config.get('how', 'inner')
                )
            else:
                result = pd.merge(
                    result, right,
                    on=config['keys'],
                    how=config.get('how', 'inner')
                )
        self.features = result
        return result

    def validate_data(self):
        """
        Run data quality checks on the merged dataset.
        Returns a report of issues found.
        """
        report = {}

        # Check for missing values
        missing = self.features.isnull().sum()
        report['missing_values'] = missing[missing > 0].to_dict()

        # Check for duplicates
        report['duplicate_rows'] = self.features.duplicated().sum()

        # Check date range
        if 'game_date' in self.features.columns:
            report['date_range'] = {
                'min': str(self.features['game_date'].min()),
                'max': str(self.features['game_date'].max()),
                'total_games': len(self.features)
            }

        # Check for outliers in key numeric columns
        numeric_cols = self.features.select_dtypes(
            include=[np.number]
        ).columns
        outlier_counts = {}
        for col in numeric_cols:
            q1 = self.features[col].quantile(0.01)
            q99 = self.features[col].quantile(0.99)
            n_outliers = (
                (self.features[col] < q1) |
                (self.features[col] > q99)
            ).sum()
            if n_outliers > 0:
                outlier_counts[col] = n_outliers
        report['potential_outliers'] = outlier_counts

        return report

Quality checks at this stage: - Are all expected data sources available and up to date? - Are there missing values, duplicates, or obvious errors? - Do team/player identifiers match across sources? - Are historical and current data on the same scale and definition?

Stage 2: Feature Engineering and Model Training

Feature engineering transforms raw data into predictive variables. This stage draws on the techniques from Chapters 9--15.

Key principles: - Use rolling windows rather than season-long averages to capture current form - Adjust for opponent quality (strength of schedule) - Include contextual features (home/away, rest days, travel distance) - Engineer interaction features where domain knowledge suggests them - Avoid look-ahead bias: features must use only information available before the game

class FeatureEngineer:
    """
    Generate predictive features from cleaned sports data.
    All features respect temporal ordering to avoid look-ahead bias.
    """

    def __init__(self, data, date_col='game_date', team_col='team'):
        self.data = data.sort_values(date_col).copy()
        self.date_col = date_col
        self.team_col = team_col

    def rolling_average(self, col, windows=[5, 10, 20],
                        min_periods=3):
        """
        Calculate rolling averages over recent games.
        Uses shift(1) to exclude the current game (no look-ahead).
        """
        for window in windows:
            feature_name = f'{col}_rolling_{window}'
            self.data[feature_name] = (
                self.data.groupby(self.team_col)[col]
                .transform(
                    lambda x: x.shift(1).rolling(
                        window=window, min_periods=min_periods
                    ).mean()
                )
            )
        return self

    def exponential_weighted_average(self, col, spans=[5, 15]):
        """
        Exponentially weighted moving average for recency weighting.
        """
        for span in spans:
            feature_name = f'{col}_ewm_{span}'
            self.data[feature_name] = (
                self.data.groupby(self.team_col)[col]
                .transform(
                    lambda x: x.shift(1).ewm(
                        span=span, min_periods=3
                    ).mean()
                )
            )
        return self

    def strength_of_schedule(self, rating_col, opponent_col):
        """
        Calculate strength of schedule using opponent ratings.
        """
        # Map opponent rating to each game
        opp_ratings = (
            self.data[[self.date_col, self.team_col, rating_col]]
            .rename(columns={
                self.team_col: opponent_col,
                rating_col: 'opp_rating'
            })
        )
        self.data = pd.merge(
            self.data, opp_ratings,
            on=[self.date_col, opponent_col],
            how='left'
        )

        # Rolling average of opponent ratings
        self.data['sos_10'] = (
            self.data.groupby(self.team_col)['opp_rating']
            .transform(
                lambda x: x.shift(1).rolling(10, min_periods=3).mean()
            )
        )
        return self

    def rest_days(self, min_rest=0, max_rest=10):
        """Calculate rest days since last game, capped at max_rest."""
        self.data['rest_days'] = (
            self.data.groupby(self.team_col)[self.date_col]
            .diff().dt.days.clip(min_rest, max_rest)
        )
        return self

    def get_features(self):
        """Return the dataset with all engineered features."""
        return self.data.dropna()

Model training follows the approaches detailed in the modeling chapters, with rigorous cross-validation and out-of-sample testing. The key reminder: never evaluate model performance on data that was used during training or feature selection.

Stage 3: Model Prediction and Signal Generation

Once models are trained and validated, they generate predictions for upcoming events. A signal is a model's output translated into a directional bet recommendation.

class SignalGenerator:
    """
    Generate betting signals from model predictions.
    Compares model probabilities to market-implied probabilities.
    """

    def __init__(self, model, feature_columns):
        self.model = model
        self.feature_columns = feature_columns

    def generate_predictions(self, upcoming_games):
        """Generate probability estimates for upcoming games."""
        X = upcoming_games[self.feature_columns]
        predictions = self.model.predict_proba(X)

        upcoming_games = upcoming_games.copy()
        upcoming_games['model_prob_home'] = predictions[:, 1]
        upcoming_games['model_prob_away'] = 1 - predictions[:, 1]
        return upcoming_games

    def calculate_edge(self, games_with_predictions):
        """
        Calculate edge: difference between model probability and
        market-implied probability.
        """
        df = games_with_predictions.copy()

        # Convert American odds to implied probabilities
        df['market_prob_home'] = df['home_odds'].apply(
            self._american_to_implied
        )
        df['market_prob_away'] = df['away_odds'].apply(
            self._american_to_implied
        )

        # Remove vig to get no-vig market probabilities
        total_implied = (
            df['market_prob_home'] + df['market_prob_away']
        )
        df['market_prob_home_novig'] = (
            df['market_prob_home'] / total_implied
        )
        df['market_prob_away_novig'] = (
            df['market_prob_away'] / total_implied
        )

        # Calculate edge
        df['edge_home'] = (
            df['model_prob_home'] - df['market_prob_home_novig']
        )
        df['edge_away'] = (
            df['model_prob_away'] - df['market_prob_away_novig']
        )

        return df

    def filter_signals(self, df, min_edge=0.03,
                       min_confidence=0.55):
        """
        Filter for actionable signals meeting minimum edge
        and confidence thresholds.
        """
        signals = []

        for _, row in df.iterrows():
            if (row['edge_home'] >= min_edge and
                    row['model_prob_home'] >= min_confidence):
                signals.append({
                    'game': f"{row['away_team']} @ {row['home_team']}",
                    'date': row['game_date'],
                    'side': 'HOME',
                    'model_prob': row['model_prob_home'],
                    'market_prob': row['market_prob_home_novig'],
                    'edge': row['edge_home'],
                    'odds': row['home_odds'],
                    'sport': row.get('sport', 'unknown')
                })

            if (row['edge_away'] >= min_edge and
                    row['model_prob_away'] >= min_confidence):
                signals.append({
                    'game': f"{row['away_team']} @ {row['home_team']}",
                    'date': row['game_date'],
                    'side': 'AWAY',
                    'model_prob': row['model_prob_away'],
                    'market_prob': row['market_prob_away_novig'],
                    'edge': row['edge_away'],
                    'odds': row['away_odds'],
                    'sport': row.get('sport', 'unknown')
                })

        return pd.DataFrame(signals)

    @staticmethod
    def _american_to_implied(american_odds):
        """Convert American odds to implied probability."""
        if american_odds > 0:
            return 100 / (american_odds + 100)
        else:
            return abs(american_odds) / (abs(american_odds) + 100)

Stage 4: Market Comparison and Edge Identification

Signals become actionable only when compared to actual market prices. This stage involves:

1. Line shopping: Comparing prices across multiple sportsbooks to find the best available odds for each signal.
2. Edge calculation: Computing the expected value of each bet at the best available price.
3. Edge thresholds: Applying minimum edge requirements (typically 2--5% for sides and totals, higher for props and parlays) to filter out marginal signals.
4. Market timing: Considering whether to bet now or wait for potential line movement in your favor.

The expected value of a bet is:

$$\text{EV} = p_{\text{model}} \times \text{Payout} - (1 - p_{\text{model}}) \times \text{Stake}$$

$$\text{EV\%} = p_{\text{model}} \times (d - 1) - (1 - p_{\text{model}})$$

where $d$ is the decimal odds and $p_{\text{model}}$ is your model's estimated probability of winning.

Stage 5: Bet Sizing and Portfolio Construction

Once you have identified positive-EV bets, you must determine how much to wager on each. This stage applies the Kelly Criterion and portfolio management concepts from Chapter 4 and earlier in this chapter (Section 41.2).

Stage 6: Bet Placement and Execution

Bet placement may seem mechanical, but several considerations affect execution quality:

• Timing: Odds can change rapidly, especially close to game time. Place bets promptly after decisions are made.
• Account management: Distribute bets across multiple sportsbook accounts to avoid triggering limits at any single book.
• Odds verification: Always verify that the odds at the time of placement match or exceed the odds assumed in your analysis.
• Record keeping: Log every bet with timestamp, odds, stake, sportsbook, sport, bet type, and the signal that generated it.

Stage 7: Settlement and Record-Keeping

After events conclude, bets settle and must be recorded:

class BettingLedger:
    """
    Comprehensive bet tracking and record-keeping system.
    """

    def __init__(self):
        self.bets = []

    def record_bet(self, bet_info):
        """
        Record a placed bet with all relevant metadata.

        Parameters
        ----------
        bet_info : dict
            Must include: date, sport, league, game, side,
            bet_type, odds, stake, sportsbook, model_name,
            model_prob, edge_at_placement
        """
        required = [
            'date', 'sport', 'game', 'side', 'odds',
            'stake', 'sportsbook', 'model_prob'
        ]
        for field in required:
            if field not in bet_info:
                raise ValueError(f"Missing required field: {field}")

        bet_info['status'] = 'pending'
        bet_info['result'] = None
        bet_info['pnl'] = None
        bet_info['placed_at'] = datetime.now().isoformat()
        self.bets.append(bet_info)

    def settle_bet(self, bet_index, result):
        """
        Settle a bet with the outcome.

        Parameters
        ----------
        bet_index : int
            Index of the bet in self.bets.
        result : str
            'win', 'loss', or 'push'.
        """
        bet = self.bets[bet_index]
        bet['result'] = result
        bet['status'] = 'settled'

        if result == 'win':
            if bet['odds'] > 0:
                bet['pnl'] = bet['stake'] * (bet['odds'] / 100)
            else:
                bet['pnl'] = bet['stake'] * (100 / abs(bet['odds']))
        elif result == 'loss':
            bet['pnl'] = -bet['stake']
        else:  # push
            bet['pnl'] = 0.0

        bet['settled_at'] = datetime.now().isoformat()

    def to_dataframe(self):
        """Convert bet ledger to pandas DataFrame for analysis."""
        return pd.DataFrame(self.bets)

    def summary(self):
        """Generate summary statistics."""
        df = self.to_dataframe()
        settled = df[df['status'] == 'settled']

        if len(settled) == 0:
            return "No settled bets."

        total_staked = settled['stake'].sum()
        total_pnl = settled['pnl'].sum()
        roi = total_pnl / total_staked * 100
        win_rate = (settled['result'] == 'win').mean() * 100

        return {
            'total_bets': len(settled),
            'total_staked': round(total_staked, 2),
            'total_pnl': round(total_pnl, 2),
            'roi_pct': round(roi, 2),
            'win_rate_pct': round(win_rate, 1),
            'avg_odds': round(settled['odds'].mean(), 1),
            'avg_stake': round(settled['stake'].mean(), 2),
            'max_drawdown': round(
                settled['pnl'].cumsum().expanding().apply(
                    lambda x: (x.iloc[-1] - x.max()),
                    raw=False
                ).min(), 2
            )
        }

Stage 8: Performance Review and Model Update

The final stage closes the loop. Review performance regularly (weekly, monthly, quarterly) and use the insights to update models and processes. This stage is detailed further in Section 41.4.

41.2 Portfolio Approach to Sports Betting

Treating Bets as a Portfolio

One of the most powerful conceptual frameworks in this book is the analogy between sports betting and investment portfolio management. Just as a sophisticated investor diversifies across asset classes, sectors, and geographies to optimize risk-adjusted returns, a serious bettor should diversify across sports, bet types, markets, and timeframes.

The key insight is that individual bet outcomes are highly uncertain, but the aggregate performance of a well-constructed portfolio of bets is much more predictable. This is a direct application of the law of large numbers and the central limit theorem.

Diversification Across Sports

Different sports offer different types of edges, with different variance profiles and different seasonal schedules:

By maintaining active models across multiple sports, you ensure a steady flow of betting opportunities throughout the year and reduce dependence on any single sport's edge persistence.

Diversification Across Market Types

Within each sport, diversification across market types is valuable: - Sides (spreads/handicaps): Lower margins, higher efficiency, smaller edges - Totals (over/unders): Often less efficient than sides, particularly in niche sports - Moneylines: Profitable for underdogs in certain sports (MLB, NHL) - Player props: Higher margins but less efficient pricing, especially for non-star players - Futures: Long-term markets with high margins but potential for significant mispricing - Live/in-play: Dynamic markets where speed and model quality create edge

Risk Budgeting

Risk budgeting is the process of allocating your total bankroll across different sports, strategies, and bet types based on expected edge, confidence, and correlation.

A formal risk budget specifies:

1. Total bankroll: The total amount allocated to sports betting.
2. Sport-level allocation: What fraction of the bankroll is available for each sport.
3. Strategy-level allocation: Within each sport, how much is allocated to each strategy or model.
4. Per-bet sizing: Maximum and typical bet sizes, typically derived from the Kelly Criterion.

class RiskBudget:
    """
    Risk budgeting system for multi-sport betting operations.
    Allocates bankroll across sports and strategies based on
    expected edge, confidence, and correlation.
    """

    def __init__(self, total_bankroll):
        self.total_bankroll = total_bankroll
        self.allocations = {}
        self.current_exposure = {}

    def set_allocation(self, sport, strategy, pct_of_bankroll,
                       max_per_bet_pct=0.03):
        """
        Set risk allocation for a sport/strategy combination.

        Parameters
        ----------
        sport : str
            Sport name (e.g., 'NFL', 'NBA').
        strategy : str
            Strategy name (e.g., 'sides_model', 'player_props').
        pct_of_bankroll : float
            Maximum percentage of total bankroll allocated.
        max_per_bet_pct : float
            Maximum single bet as percentage of total bankroll.
        """
        key = (sport, strategy)
        self.allocations[key] = {
            'max_allocation': pct_of_bankroll * self.total_bankroll,
            'max_per_bet': max_per_bet_pct * self.total_bankroll,
            'pct_of_bankroll': pct_of_bankroll
        }
        self.current_exposure[key] = 0.0

    def can_place_bet(self, sport, strategy, stake):
        """Check if a bet fits within risk budget constraints."""
        key = (sport, strategy)
        if key not in self.allocations:
            return False, "No allocation for this sport/strategy"

        alloc = self.allocations[key]

        if stake > alloc['max_per_bet']:
            return False, (
                f"Stake ${stake:.2f} exceeds max per bet "
                f"${alloc['max_per_bet']:.2f}"
            )

        if (self.current_exposure[key] + stake >
                alloc['max_allocation']):
            return False, (
                f"Would exceed allocation: current exposure "
                f"${self.current_exposure[key]:.2f} + "
                f"${stake:.2f} > ${alloc['max_allocation']:.2f}"
            )

        # Check total portfolio exposure
        total_exposure = sum(self.current_exposure.values()) + stake
        if total_exposure > 0.25 * self.total_bankroll:
            return False, (
                f"Would exceed total exposure limit: "
                f"${total_exposure:.2f} > "
                f"${0.25 * self.total_bankroll:.2f}"
            )

        return True, "OK"

    def record_bet(self, sport, strategy, stake):
        """Record a bet placement against the risk budget."""
        key = (sport, strategy)
        can_bet, msg = self.can_place_bet(sport, strategy, stake)
        if not can_bet:
            raise ValueError(f"Cannot place bet: {msg}")
        self.current_exposure[key] += stake

    def settle_bet(self, sport, strategy, stake):
        """Release exposure when a bet settles."""
        key = (sport, strategy)
        self.current_exposure[key] = max(
            0, self.current_exposure[key] - stake
        )

    def portfolio_summary(self):
        """Display current portfolio allocation and exposure."""
        summary = []
        for key, alloc in self.allocations.items():
            sport, strategy = key
            exposure = self.current_exposure.get(key, 0)
            utilization = (
                exposure / alloc['max_allocation'] * 100
                if alloc['max_allocation'] > 0 else 0
            )
            summary.append({
                'sport': sport,
                'strategy': strategy,
                'allocation': alloc['max_allocation'],
                'current_exposure': exposure,
                'utilization_pct': round(utilization, 1)
            })
        return pd.DataFrame(summary)


# Example usage
budget = RiskBudget(total_bankroll=10000)
budget.set_allocation('NFL', 'sides_model', 0.15, 0.02)
budget.set_allocation('NFL', 'player_props', 0.05, 0.01)
budget.set_allocation('NBA', 'sides_model', 0.15, 0.02)
budget.set_allocation('NBA', 'totals_model', 0.10, 0.015)
budget.set_allocation('MLB', 'moneyline_model', 0.10, 0.015)
budget.set_allocation('Soccer', 'xg_model', 0.10, 0.015)

Correlation and Portfolio Risk

Just as financial portfolio theory emphasizes that the risk of a portfolio depends on the correlations between its components, the risk of a betting portfolio depends on the correlations between outcomes:

$$\sigma_{\text{portfolio}}^2 = \sum_i w_i^2 \sigma_i^2 + 2\sum_{i

where $w_i$ is the weight of bet $i$, $\sigma_i$ is the standard deviation of bet $i$'s return, and $\rho_{ij}$ is the correlation between bets $i$ and $j$.

In practice, most sports bets across different games and sports have very low correlation (near zero), which is a powerful diversification benefit. However, correlations can arise from:

• Same-game bets: Multiple bets on the same game (side, total, player props) are correlated.
• Systematic factors: Weather affecting multiple games at the same venue, league-wide trends, or shared opponents.
• Model errors: If the same model generates signals across many games, a systematic model flaw creates correlated risk.

Managing these correlations --- by diversifying across sports, strategies, and models --- is a key advantage of the portfolio approach.

41.3 Integrating Multiple Models and Signals

The Case for Ensemble Approaches

No single model captures all relevant information about a sporting event. Different models may emphasize different features, use different algorithms, or be trained on different data windows. Combining multiple models into an ensemble typically produces more accurate and more robust predictions than any individual model alone.

This principle is well-established in machine learning (Random Forests and gradient boosting are ensemble methods) and in financial forecasting. In sports betting, ensemble approaches are particularly valuable because:

1. Reduced model risk: If one model has a systematic flaw, the ensemble dilutes its impact.
2. Broader information capture: Different models may capture different aspects of the data.
3. More stable predictions: Ensembles tend to produce less volatile predictions over time.
4. Better calibration: Averaging across models often improves probability calibration.

Model Weighting Strategies

The simplest ensemble is a simple average of model predictions. More sophisticated approaches weight models based on their performance:

Inverse-error weighting: Weight each model inversely proportional to its recent prediction error:

$$w_i = \frac{1/\text{MSE}_i}{\sum_j 1/\text{MSE}_j}$$

where $\text{MSE}_i$ is model $i$'s mean squared error over a recent evaluation window.

Bayesian Model Averaging (BMA): Weight models by their posterior probability:

$$P(y | \text{data}) = \sum_i P(y | M_i, \text{data}) \times P(M_i | \text{data})$$

where $P(M_i | \text{data})$ is the posterior probability of model $M_i$ given the observed data.

Performance-based dynamic weighting: Adjust weights over time based on recent performance, giving more weight to models that are currently performing well:

class EnsemblePredictor:
    """
    Combine multiple prediction models with dynamic weighting.
    """

    def __init__(self, models, model_names=None):
        """
        Parameters
        ----------
        models : list
            List of trained model objects, each with predict_proba.
        model_names : list of str, optional
            Names for each model.
        """
        self.models = models
        self.model_names = (
            model_names or
            [f'model_{i}' for i in range(len(models))]
        )
        self.n_models = len(models)
        self.weights = np.ones(self.n_models) / self.n_models
        self.performance_history = {
            name: [] for name in self.model_names
        }

    def predict_ensemble(self, X, method='weighted_average'):
        """
        Generate ensemble predictions.

        Parameters
        ----------
        X : array-like
            Feature matrix for prediction.
        method : str
            'simple_average', 'weighted_average', or 'stacking'.

        Returns
        -------
        ensemble_prob : array
            Ensemble probability estimates.
        individual_probs : dict
            Individual model predictions.
        """
        individual_probs = {}
        for i, (model, name) in enumerate(
            zip(self.models, self.model_names)
        ):
            probs = model.predict_proba(X)[:, 1]
            individual_probs[name] = probs

        if method == 'simple_average':
            ensemble_prob = np.mean(
                list(individual_probs.values()), axis=0
            )
        elif method == 'weighted_average':
            ensemble_prob = np.zeros(len(X))
            for i, name in enumerate(self.model_names):
                ensemble_prob += (
                    self.weights[i] * individual_probs[name]
                )
        else:
            raise ValueError(f"Unknown method: {method}")

        return ensemble_prob, individual_probs

    def update_weights(self, y_true, individual_probs,
                       window=50, method='inverse_brier'):
        """
        Update model weights based on recent performance.

        Parameters
        ----------
        y_true : array
            Actual outcomes (0 or 1).
        individual_probs : dict
            Model predictions for the evaluated games.
        window : int
            Number of recent predictions to evaluate.
        method : str
            'inverse_brier' or 'inverse_logloss'.
        """
        scores = {}
        for name in self.model_names:
            preds = np.array(
                self.performance_history[name][-window:]
            )
            actuals = y_true[-len(preds):]

            if method == 'inverse_brier':
                brier = np.mean((preds - actuals) ** 2)
                scores[name] = 1.0 / max(brier, 0.001)
            elif method == 'inverse_logloss':
                eps = 1e-7
                preds_clipped = np.clip(preds, eps, 1 - eps)
                logloss = -np.mean(
                    actuals * np.log(preds_clipped) +
                    (1 - actuals) * np.log(1 - preds_clipped)
                )
                scores[name] = 1.0 / max(logloss, 0.001)

        total_score = sum(scores.values())
        for i, name in enumerate(self.model_names):
            self.weights[i] = scores[name] / total_score

    def record_predictions(self, individual_probs):
        """Store predictions for performance tracking."""
        for name, probs in individual_probs.items():
            self.performance_history[name].extend(probs.tolist())

    def weight_summary(self):
        """Display current model weights."""
        return pd.DataFrame({
            'model': self.model_names,
            'weight': np.round(self.weights, 4)
        }).sort_values('weight', ascending=False)

Signal Combination and Consensus Pricing

Beyond combining model probabilities, you can combine signals from fundamentally different analytical approaches:

Quantitative model signals: Output from regression, machine learning, or simulation models.

Market-based signals: Information extracted from betting market data: - Line movement direction and magnitude - Opening line vs. current line divergence - Sharp money indicators (line moves on low public betting percentage) - Closing line value historical patterns

Qualitative signals: Expert judgment, insider knowledge, situational analysis.

Consensus pricing integrates all available information into a single probability estimate:

$$p_{\text{consensus}} = w_{\text{model}} \cdot p_{\text{model}} + w_{\text{market}} \cdot p_{\text{market}} + w_{\text{qual}} \cdot p_{\text{qualitative}}$$

A practical approach assigns initial weights based on historical accuracy: - Quantitative model: 50--60% weight - Market-implied probability (no-vig): 30--40% weight - Qualitative adjustment: 5--15% weight

The market-implied probability serves as a strong prior. Your model should move the consensus away from the market price only when the edge is meaningful and the model's historical accuracy justifies confidence.

When Models Disagree

Disagreement among models is informative. When two reliable models strongly disagree on the probability of an outcome, it often indicates:

1. Genuine uncertainty: The event is harder to predict than average, and caution is warranted.
2. Different information sets: One model may be capturing something the other misses. Investigate the source of disagreement.
3. Model error: One or both models may be malfunctioning on this specific input. Check for unusual feature values or data quality issues.

A simple rule: when your models strongly disagree, reduce position size or pass on the bet entirely. The consensus edge is ambiguous, and the risk of model error is elevated.

41.4 Performance Attribution and Review

Why Attribution Matters

Knowing your overall P&L tells you whether you are winning or losing, but it does not tell you why. Performance attribution decomposes your results into components --- by sport, strategy, model, bet type, time period, and other dimensions --- to identify what is working, what is not, and where to focus improvement efforts.

Without attribution, you are flying blind. A positive overall P&L might mask a failing strategy subsidized by a strong one. A negative month might represent normal variance in a sound operation, or it might signal that a model has broken. Attribution tells you the difference.

Implementing Performance Attribution

class PerformanceAttribution:
    """
    Decompose betting P&L across multiple dimensions.
    """

    def __init__(self, bet_data):
        """
        Parameters
        ----------
        bet_data : pd.DataFrame
            DataFrame of settled bets with columns: date, sport,
            strategy, model_name, bet_type, odds, stake, pnl,
            model_prob, edge_at_placement, result
        """
        self.data = bet_data.copy()
        self.data['date'] = pd.to_datetime(self.data['date'])
        self.data['roi'] = self.data['pnl'] / self.data['stake']

    def by_dimension(self, dimension):
        """
        Attribute P&L by a single dimension.

        Parameters
        ----------
        dimension : str
            Column name to group by (e.g., 'sport', 'strategy').

        Returns
        -------
        pd.DataFrame with attribution metrics.
        """
        grouped = self.data.groupby(dimension).agg(
            n_bets=('pnl', 'count'),
            total_staked=('stake', 'sum'),
            total_pnl=('pnl', 'sum'),
            avg_odds=('odds', 'mean'),
            win_rate=('result', lambda x: (x == 'win').mean()),
            avg_edge=('edge_at_placement', 'mean'),
            avg_model_prob=('model_prob', 'mean')
        ).reset_index()

        grouped['roi_pct'] = (
            grouped['total_pnl'] / grouped['total_staked'] * 100
        )
        grouped['pnl_contribution_pct'] = (
            grouped['total_pnl'] / grouped['total_pnl'].sum() * 100
        )

        return grouped.sort_values('total_pnl', ascending=False)

    def by_time_period(self, freq='M'):
        """
        Attribute P&L by time period.

        Parameters
        ----------
        freq : str
            Pandas frequency string ('W' for weekly, 'M' for monthly).
        """
        self.data['period'] = self.data['date'].dt.to_period(freq)

        time_summary = self.data.groupby('period').agg(
            n_bets=('pnl', 'count'),
            total_staked=('stake', 'sum'),
            total_pnl=('pnl', 'sum'),
            win_rate=('result', lambda x: (x == 'win').mean())
        ).reset_index()

        time_summary['roi_pct'] = (
            time_summary['total_pnl'] /
            time_summary['total_staked'] * 100
        )
        time_summary['cumulative_pnl'] = (
            time_summary['total_pnl'].cumsum()
        )

        return time_summary

    def edge_analysis(self, edge_bins=None):
        """
        Analyze performance by size of estimated edge at placement.
        Helps determine if larger estimated edges produce
        proportionally larger returns.
        """
        if edge_bins is None:
            edge_bins = [0, 0.02, 0.04, 0.06, 0.10, 0.20, 1.0]

        self.data['edge_bin'] = pd.cut(
            self.data['edge_at_placement'],
            bins=edge_bins,
            labels=[
                f'{edge_bins[i]:.0%}-{edge_bins[i+1]:.0%}'
                for i in range(len(edge_bins) - 1)
            ]
        )

        edge_summary = self.data.groupby('edge_bin').agg(
            n_bets=('pnl', 'count'),
            total_pnl=('pnl', 'sum'),
            total_staked=('stake', 'sum'),
            win_rate=('result', lambda x: (x == 'win').mean()),
            avg_edge=('edge_at_placement', 'mean')
        ).reset_index()

        edge_summary['roi_pct'] = (
            edge_summary['total_pnl'] /
            edge_summary['total_staked'] * 100
        )

        return edge_summary

    def closing_line_value_analysis(self):
        """
        Analyze CLV: did we beat the closing line?
        Closing line value is the strongest predictor of
        long-term betting success.
        """
        if 'closing_odds' not in self.data.columns:
            return "Closing odds data not available."

        self.data['clv'] = self.data.apply(
            lambda row: self._calculate_clv(
                row['odds'], row['closing_odds']
            ),
            axis=1
        )

        clv_summary = {
            'avg_clv_pct': self.data['clv'].mean() * 100,
            'pct_beating_close': (
                (self.data['clv'] > 0).mean() * 100
            ),
            'clv_by_sport': self.data.groupby('sport')['clv']
                .mean().to_dict()
        }

        return clv_summary

    def drawdown_analysis(self):
        """
        Calculate drawdown metrics for the portfolio.
        """
        cumulative = self.data.sort_values('date')['pnl'].cumsum()
        running_max = cumulative.expanding().max()
        drawdown = cumulative - running_max

        return {
            'max_drawdown': drawdown.min(),
            'max_drawdown_pct': (
                drawdown.min() / running_max[drawdown.idxmin()]
                * 100 if running_max[drawdown.idxmin()] > 0
                else None
            ),
            'current_drawdown': drawdown.iloc[-1],
            'time_in_drawdown_pct': (
                (drawdown < 0).mean() * 100
            )
        }

    @staticmethod
    def _calculate_clv(bet_odds, closing_odds):
        """Calculate closing line value."""
        if bet_odds > 0:
            bet_implied = 100 / (bet_odds + 100)
        else:
            bet_implied = abs(bet_odds) / (abs(bet_odds) + 100)

        if closing_odds > 0:
            close_implied = 100 / (closing_odds + 100)
        else:
            close_implied = (
                abs(closing_odds) / (abs(closing_odds) + 100)
            )

        return close_implied - bet_implied

    def full_report(self):
        """Generate comprehensive performance report."""
        report = {
            'overall': {
                'total_bets': len(self.data),
                'total_staked': self.data['stake'].sum(),
                'total_pnl': self.data['pnl'].sum(),
                'roi_pct': (
                    self.data['pnl'].sum() /
                    self.data['stake'].sum() * 100
                ),
                'win_rate': (
                    (self.data['result'] == 'win').mean() * 100
                ),
                'sharpe_ratio': self._betting_sharpe()
            },
            'by_sport': self.by_dimension('sport'),
            'by_strategy': self.by_dimension('strategy'),
            'by_time': self.by_time_period('M'),
            'by_edge': self.edge_analysis(),
            'drawdown': self.drawdown_analysis()
        }

        if 'closing_odds' in self.data.columns:
            report['clv_analysis'] = (
                self.closing_line_value_analysis()
            )

        return report

    def _betting_sharpe(self):
        """
        Calculate a Sharpe-like ratio for betting returns.
        Uses daily P&L grouped by date.
        """
        daily_pnl = self.data.groupby(
            self.data['date'].dt.date
        )['pnl'].sum()

        if daily_pnl.std() == 0:
            return float('inf') if daily_pnl.mean() > 0 else 0

        # Annualized (assuming ~300 betting days per year)
        return (
            daily_pnl.mean() / daily_pnl.std() * np.sqrt(300)
        )

What to Look For in Reviews

Regular performance reviews should examine:

1. Overall P&L trend: Is the cumulative P&L curve trending upward, flat, or declining? Are recent results consistent with historical performance?

2. Sport-level attribution: Which sports are contributing positively? Which are dragging? Should you reallocate capital?

3. Strategy-level attribution: Are all strategies performing as expected? Has any strategy's edge decayed?

4. Edge calibration: Are bets with larger estimated edges actually producing proportionally larger returns? If not, there may be a calibration problem in your models.

5. Closing line value (CLV): The single most important diagnostic. If you are consistently beating the closing line, your edge is real and sustainable. If not, even positive P&L may be variance.

6. Drawdown analysis: How deep are drawdowns relative to your bankroll? Are drawdowns consistent with the variance implied by your bet sizes and edge estimates?

7. Sample size adequacy: Do you have enough bets in each category to draw statistically meaningful conclusions? A sport or strategy with fewer than 100 settled bets is often too small for reliable attribution.

41.5 Building a Sustainable Betting Operation

Long-Term Thinking

The difference between a hobbyist bettor and a sustainable betting operation is the time horizon. A hobbyist focuses on today's games. A sustainable operation thinks in terms of seasons, years, and decades.

Long-term thinking manifests in several concrete practices:

Process over outcomes: Judge your operation by the quality of its process, not by short-term results. A losing week with good process is better than a winning week driven by luck. Over thousands of bets, good process produces good results; outcome-focused thinking leads to emotional decision-making and process degradation.

Continuous improvement: Treat your operation as a system that can always be improved. Every model can be refined. Every data source can be augmented. Every process can be streamlined. Schedule regular time for research and development, even when current results are good.

Intellectual humility: The market is your opponent, and it is sophisticated. Be willing to acknowledge when your models are wrong, when your edge has decayed, and when the market has adapted to your strategy. The most dangerous state is overconfidence in a model that worked in the past but no longer works today.

Continuous Learning

The sports betting landscape evolves constantly. Teams change strategies, leagues change rules, sportsbooks improve their models, and new data sources become available. A sustainable operation must evolve in parallel.

Learning priorities: - Stay current on advances in machine learning and statistical methodology - Follow academic research in sports analytics and prediction markets - Monitor industry developments (new operators, regulatory changes, product innovations) - Track changes in the sports themselves (rule changes, strategic evolution, new metrics) - Engage with the sports analytics community (conferences, online forums, publications)

Adapting to Market Changes

Markets adapt. An edge that exists today may not exist tomorrow. Common sources of edge decay:

1. Sportsbook model improvement: As operators invest in better models, pricing becomes more accurate, and edge opportunities shrink.
2. Information dissemination: When a novel data source or analytical approach becomes widely known, its edge is competed away.
3. Behavioral changes: Public betting patterns can shift in response to media coverage, social media, or cultural changes.
4. Rule changes: Sporting rule changes (pitch clock in MLB, new replay rules, etc.) can invalidate models trained on pre-change data.
5. Market structure changes: Regulatory changes, new operators entering the market, or changes in operator behavior (limit policies, product offerings) can alter the landscape.

Adaptation strategies: - Maintain multiple models and regularly evaluate their performance - Develop new models and data sources continuously, even when current ones are working - Monitor edge metrics (CLV, ROI by strategy) for signs of decay - Be willing to retire strategies that are no longer profitable - Be willing to scale into new strategies that show promise

When to Scale Up and Down

Scaling up (increasing bet sizes or adding new sports/strategies) is appropriate when: - You have a proven track record over a statistically meaningful sample (500+ bets with positive ROI and positive CLV) - Your bankroll has grown sufficiently to support larger bets while maintaining sound bankroll management - You have identified new edge sources with strong backtesting results and out-of-sample validation - Your operational infrastructure (data, models, execution, record-keeping) can handle increased volume

Scaling down is appropriate when: - A prolonged drawdown exceeds expectations based on your edge and variance estimates - Performance attribution reveals that key strategies have lost their edge - Market conditions have changed in ways that undermine your models (rule changes, new data availability to the public, operator behavior changes) - Personal circumstances require reduced risk exposure - You detect psychological warning signs: overconfidence, revenge betting, or erosion of disciplinary standards

The scaling decision framework:

$$\text{Scale Factor} = \frac{\text{Current Kelly Fraction}}{\text{Baseline Kelly Fraction}}$$

If your estimated edge has increased and your bankroll has grown, the Kelly Criterion naturally suggests larger bets. If your edge has decreased or your bankroll has shrunk, Kelly suggests smaller bets. Use fractional Kelly (typically 25--50% of full Kelly) to provide a margin of safety.

Operational Discipline

Sustainable operations are built on disciplined execution of well-defined processes:

1. Daily routine: Check data feeds, review model outputs, identify actionable signals, execute bets, update records.
2. Weekly review: Settle all bets from the previous week, update performance tracking, review any notable outcomes or model anomalies.
3. Monthly review: Comprehensive performance attribution, model performance evaluation, risk budget review, identify strategic adjustments.
4. Quarterly deep dive: Full model recalibration, backtest against recent data, research new approaches, evaluate new data sources, assess competitive landscape.
5. Annual review: Comprehensive operational review, set goals for the next year, major strategic decisions about scaling, sport selection, and technology investment.

Key Insight for Bettors: The most common reason profitable bettors fail in the long run is not model error --- it is process failure. They stop tracking bets meticulously. They deviate from their bankroll management rules after a winning streak. They chase losses after a drawdown. They stop updating their models because "they're working fine." Building and maintaining disciplined processes is harder than building a good model, and it is more important for long-term success.

41.6 Chapter Summary

This chapter integrated the skills, models, and concepts from the entire textbook into a practical, operational framework for sports betting.

Key takeaways:

1. The complete betting workflow consists of eight stages: data collection, feature engineering, prediction, market comparison, bet sizing, execution, settlement, and review. Each stage has specific quality checks and decision criteria. The workflow is a continuous loop, with performance review feeding back into model improvement and data collection.

2. The portfolio approach treats sports betting as a diversified investment operation. By spreading bets across multiple sports, market types, strategies, and timeframes, you reduce variance and create a more predictable return stream. Risk budgeting formalizes how capital is allocated across different activities, and correlation management ensures that concentrated exposure does not create catastrophic risk.

3. Ensemble methods combine multiple models and signals for more robust predictions. Dynamic model weighting, based on recent performance, ensures that the ensemble adapts to changing conditions. Consensus pricing integrates quantitative model output, market information, and qualitative judgment into a single probability estimate. When models disagree, caution is warranted.

4. Performance attribution decomposes P&L by sport, strategy, model, edge size, and time period to identify what is working and what is not. Closing line value analysis is the single most important diagnostic for long-term sustainability. Regular reviews at daily, weekly, monthly, and quarterly intervals ensure timely identification of problems and opportunities.

5. Sustainable operations require long-term thinking, continuous learning, adaptation to market changes, and disciplined scaling. Process quality matters more than any individual model. The greatest risks to long-term success are psychological --- overconfidence, discipline erosion, and failure to adapt --- not technical.

Looking Ahead: In Chapter 42, we look beyond current practice to the research frontier, exploring open problems in sports betting, applications of causal inference, reinforcement learning, and market microstructure research. This final chapter points toward the future of quantitative sports betting and the opportunities that await the next generation of analytical bettors.

Chapter 41 Exercises:

1. Implement the complete BettingDataPipeline class for a sport of your choice. Collect data from at least two sources, clean and merge them, and run the validate_data method. Document any data quality issues you discover.

2. Design a risk budget for a $5,000 bankroll that covers three sports and five total strategies. Specify the allocation percentages, maximum per-bet sizes, and the rationale for your choices.

3. Build an ensemble predictor combining at least two different model types (e.g., logistic regression and random forest) for a sport of your choice. Implement inverse-Brier weighting and compare the ensemble's Brier score to each individual model's.

4. Using at least 200 historical bets (real or simulated), perform a full performance attribution analysis. Generate the by_sport, by_time, and edge_analysis reports. Write a one-page analysis of what the attribution reveals.

5. Create a "betting operations calendar" that specifies your daily, weekly, monthly, and quarterly review activities, including specific metrics to check at each interval and decision criteria for scaling up or down.