Chapter 20: Exercises - Recruiting Analytics

Overview

These exercises progress from basic recruiting data analysis to building complete prospect evaluation systems. You'll work with physical measurables, rating analysis, class optimization, and development projections.

Level 1: Fundamentals

Exercise 1.1: Understanding Star Ratings

Calculate the reliability weight for recruiting ratings and understand what different star levels mean.

Task: 1. Given historical outcome data, calculate the success rates for each star level 2. Determine the probability that a 4-star recruit becomes a starter vs. a 3-star recruit 3. Calculate the expected number of starters from a class of 20 recruits with the following breakdown: 2 five-stars, 8 four-stars, 10 three-stars

Starter Code:

def calculate_expected_starters(class_composition: dict,
                               success_rates: dict) -> float:
    """
    Calculate expected starters from recruiting class.

    Parameters:
    -----------
    class_composition : dict
        Number of recruits by star rating {5: 2, 4: 8, 3: 10}
    success_rates : dict
        Probability of becoming starter by star rating

    Returns:
    --------
    float : Expected number of starters
    """
    # Your code here
    pass

# Historical success rates (starter = 12+ career starts)
success_rates = {
    5: 0.85,
    4: 0.65,
    3: 0.35,
    2: 0.12
}

# Sample class
sample_class = {5: 2, 4: 8, 3: 10, 2: 0}

Expected Output: - Show expected starters for the class - Compare to actual outcomes if data available

Exercise 1.2: Physical Profile Scoring

Evaluate a prospect's physical measurables against position-specific benchmarks.

Task: 1. Create position-specific ideal ranges for key measurables 2. Score a prospect's physical profile for their listed position 3. Identify which measurements are strengths vs. weaknesses

Starter Code:

def score_physical_profile(measurables: dict,
                          position: str,
                          position_standards: dict) -> dict:
    """
    Score prospect's physical profile against position standards.

    Parameters:
    -----------
    measurables : dict
        Player's measurements {height: 74, weight: 215, forty: 4.52, ...}
    position : str
        Player position
    position_standards : dict
        Ideal ranges by position

    Returns:
    --------
    dict : Scores and assessment for each measurement
    """
    # Your code here
    pass

# Example prospect
prospect_measurables = {
    'height': 74,      # inches
    'weight': 215,
    'forty': 4.52,
    'vertical': 36,
    'shuttle': 4.15
}
position = 'WR'

Exercise 1.3: Recruiting Class Points

Calculate total recruiting class points using the standard formula.

Task: 1. Implement the 247Sports-style class points formula 2. Calculate total points for multiple recruiting classes 3. Rank classes by total points and average rating

Starter Code:

def calculate_class_points(recruits: list) -> dict:
    """
    Calculate recruiting class points.

    Parameters:
    -----------
    recruits : list
        List of recruit dicts with 'rating' key

    Returns:
    --------
    dict : Class metrics including total points, avg rating
    """
    # 247 formula approximation:
    # Points = rating * 100 (with modifiers for top recruits)
    pass

Level 2: Intermediate

Exercise 2.1: Competition-Adjusted Statistics

Adjust high school statistics based on competition level.

Task: 1. Create competition level adjustment factors 2. Apply adjustments to raw statistics 3. Compare adjusted statistics across prospects from different states/classifications

Starter Code:

def adjust_statistics_for_competition(stats: dict,
                                     competition_level: str,
                                     state: str) -> dict:
    """
    Adjust statistics based on competition level.

    Parameters:
    -----------
    stats : dict
        Raw high school statistics
    competition_level : str
        Classification (e.g., '6A', '4A', 'D1')
    state : str
        State abbreviation

    Returns:
    --------
    dict : Adjusted statistics with competition factor
    """
    # Competition factors
    state_factors = {
        'TX': 1.0, 'CA': 1.0, 'FL': 1.0,
        'OH': 0.95, 'GA': 0.95,
        'other': 0.85
    }

    classification_factors = {
        '6A': 1.0, '7A': 1.0, '8A': 1.0,
        '5A': 0.95, '4A': 0.90,
        'smaller': 0.80
    }

    # Your code here
    pass

Exercise 2.2: Position Needs Analysis

Analyze current roster to identify recruiting priorities.

Task: 1. Count players by position and class year 2. Project departures (seniors/graduates) 3. Calculate need level for each position 4. Prioritize positions for upcoming recruiting class

Starter Code:

def analyze_position_needs(roster: pd.DataFrame,
                          ideal_counts: dict) -> pd.DataFrame:
    """
    Analyze roster needs by position.

    Parameters:
    -----------
    roster : pd.DataFrame
        Current roster with position, class_year columns
    ideal_counts : dict
        Target roster counts by position

    Returns:
    --------
    pd.DataFrame : Position needs analysis
    """
    # Your code here
    pass

# Ideal scholarship counts by position
ideal_counts = {
    'QB': 3, 'RB': 4, 'WR': 8, 'TE': 3,
    'OL': 15, 'DL': 10, 'LB': 8, 'DB': 12
}

Exercise 2.3: Recruiting Class Optimization

Select the optimal recruiting class given position needs and available prospects.

Task: 1. Given a list of committed/interested prospects 2. Select 20-25 to maximize class rating while meeting position needs 3. Handle constraints (e.g., can't sign more than 4 at any position)

Starter Code:

def optimize_recruiting_class(available_prospects: pd.DataFrame,
                             position_needs: dict,
                             scholarship_limit: int = 25,
                             position_limits: dict = None) -> pd.DataFrame:
    """
    Select optimal recruiting class.

    Parameters:
    -----------
    available_prospects : pd.DataFrame
        Prospects with position, rating columns
    position_needs : dict
        Minimum needs by position
    scholarship_limit : int
        Maximum class size
    position_limits : dict
        Maximum commits per position

    Returns:
    --------
    pd.DataFrame : Optimized recruiting class
    """
    # Greedy optimization approach
    # Your code here
    pass

Level 3: Advanced

Exercise 3.1: Prospect Evaluation Model

Build a machine learning model to evaluate prospects.

Task: 1. Prepare features from measurables, ratings, and statistics 2. Train a model to predict college success (e.g., becoming starter) 3. Evaluate model performance with cross-validation 4. Interpret feature importances

Starter Code:

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

def build_prospect_model(training_data: pd.DataFrame,
                        outcome_col: str = 'became_starter') -> dict:
    """
    Build prospect evaluation model.

    Parameters:
    -----------
    training_data : pd.DataFrame
        Historical prospect data with outcomes
    outcome_col : str
        Target variable column

    Returns:
    --------
    dict : Model, performance metrics, feature importances
    """
    features = [
        'composite_rating', 'height', 'weight', 'forty_time',
        'production_score', 'competition_factor', 'position_rank'
    ]

    # Your code here
    pass

Exercise 3.2: Transfer Portal Evaluation

Evaluate transfer portal candidates for your program.

Task: 1. Build a transfer success prediction model 2. Account for factors like playing time, program tier, eligibility 3. Generate risk-adjusted recommendations 4. Compare portal candidates to traditional recruits

Starter Code:

def evaluate_transfer(transfer_data: dict,
                     origin_program: dict,
                     destination_program: dict) -> dict:
    """
    Evaluate transfer portal candidate.

    Parameters:
    -----------
    transfer_data : dict
        Player stats, rating, eligibility
    origin_program : dict
        Origin school info
    destination_program : dict
        Destination school info

    Returns:
    --------
    dict : Evaluation with success probability, risk, recommendation
    """
    # Key factors:
    # - Original recruiting rating
    # - Production at origin school
    # - Step up/down in competition
    # - Playing time history
    # - Eligibility remaining

    # Your code here
    pass

Exercise 3.3: Recruiting Efficiency Analysis

Compare recruiting efficiency across programs.

Task: 1. Calculate development efficiency (actual outcomes vs. expected from ratings) 2. Calculate wins above expectation 3. Identify programs that over/under-perform their recruiting 4. Analyze what factors distinguish efficient programs

Starter Code:

def calculate_recruiting_efficiency(program_data: pd.DataFrame) -> dict:
    """
    Calculate recruiting efficiency metrics.

    Parameters:
    -----------
    program_data : pd.DataFrame
        Historical recruit data with outcomes for a program

    Returns:
    --------
    dict : Efficiency metrics
    """
    # Expected outcomes based on star ratings
    expected_outcomes = {
        5: {'starter': 0.85, 'all_conf': 0.45, 'draft': 0.55},
        4: {'starter': 0.65, 'all_conf': 0.18, 'draft': 0.22},
        3: {'starter': 0.35, 'all_conf': 0.06, 'draft': 0.06}
    }

    # Your code here
    pass

Level 4: Expert

Exercise 4.1: Complete Recruiting Board System

Build a full recruiting board management system.

Task: 1. Track prospects with status (offer, visit, commit, signed) 2. Prioritize prospects by position need and rating 3. Generate probability-weighted class projections 4. Simulate recruiting outcomes under different scenarios

Requirements: - Handle scholarship counting - Track visit schedules - Generate reports by position - Project class rankings

Exercise 4.2: Multi-Year Roster Planning

Build a multi-year roster planning model.

Task: 1. Project roster composition 3-4 years out 2. Account for attrition, transfers, early departures 3. Identify optimal recruiting strategies for sustained success 4. Model different recruiting class scenarios

Requirements: - Handle uncertainty in player development - Model transfer portal activity - Project NFL early entries - Generate recruiting roadmaps

Exercise 4.3: NIL Valuation Model

Build a model to value recruits in the NIL era.

Task: 1. Estimate market value based on rating, position, market size 2. Model ROI from NIL investment 3. Optimize NIL budget allocation across recruiting class 4. Compare NIL investment strategies

Considerations: - Position value differences - Market size effects - Performance incentive structures - Portfolio approach to roster building

Project: Complete Recruiting Analytics Platform

Objective

Build an end-to-end recruiting analytics platform that helps a program evaluate prospects, optimize recruiting classes, and track recruiting efficiency.

Requirements

  1. Prospect Database - Store prospect profiles with measurables, ratings, statistics - Track recruiting status and visit history - Handle data from multiple rating services

  2. Evaluation Engine - Physical profile scoring - Statistical production analysis - Composite prospect scoring - Comparable player identification

  3. Class Optimization - Position needs analysis - Class composition optimization - Transfer portal integration - Budget/scholarship tracking

  4. Reporting Dashboard - Individual prospect reports - Class summaries - Position-by-position analysis - Efficiency metrics

  5. Historical Analysis - Track historical recruiting accuracy - Development efficiency over time - Recruiting trends analysis

Deliverables

  1. Working Python code for all components
  2. Sample data or data generation scripts
  3. Documentation of methodology
  4. Example reports and visualizations
  5. Analysis of historical recruiting patterns

Evaluation Criteria

  • Code quality and organization
  • Model accuracy and validation
  • Practical applicability
  • Documentation completeness
  • Visualization quality