Create app.py

app.py

@@ -0,0 +1,446 @@
+import gradio as gr
+import requests
+import json
+import ast
+import pandas as pd
+import os
+from datetime import datetime
+from huggingface_hub import snapshot_download
+from autogluon.tabular import TabularPredictor
+
+# --- Download Model and Embeddings ---
+def download_model_and_embeddings(repo_id="SebastianAndreu/2025-24679-NFL-Yards-Predictor", local_dir="nfl_model"):
+    try:
+        print(f"Downloading model from {repo_id}...")
+        model_path = snapshot_download(
+            repo_id=repo_id,
+            repo_type="model",
+            local_dir=local_dir,
+            local_dir_use_symlinks=False
+        )
+        predictor = TabularPredictor.load(os.path.join(local_dir, "model"), verbosity=0)
+        emb_df = pd.read_csv(os.path.join(local_dir, "data", "player_historical_embeddings.csv"))
+        print(f"✓ Loaded model from {repo_id}/model and embeddings from {repo_id}/data")
+        print(f"✓ Loaded {len(emb_df)} player embeddings")
+        return predictor, emb_df
+    except Exception as e:
+        print(f"Error downloading model or embeddings: {e}")
+        return None, None
+
+# Load model at startup
+print("Loading NFL Yards Prediction Model...")
+predictor, player_embeddings = download_model_and_embeddings()
+
+# Load player mappings from the same repo
+def load_player_mappings():
+    try:
+        # Try to load from downloaded model directory
+        with open("nfl_model/receiver_to_player_id.json", 'r') as f:
+            content = f.read()
+            try:
+                receiver_to_player_id = json.loads(content)
+            except json.JSONDecodeError:
+                receiver_to_player_id = ast.literal_eval(content)
+        
+        with open("nfl_model/passer_to_player_id.json", 'r') as f:
+            content = f.read()
+            try:
+                passer_to_player_id = json.loads(content)
+            except json.JSONDecodeError:
+                passer_to_player_id = ast.literal_eval(content)
+        
+        print(f"✓ Loaded {len(receiver_to_player_id)} receivers and {len(passer_to_player_id)} passers")
+        return receiver_to_player_id, passer_to_player_id
+    except Exception as e:
+        print(f"Error loading player mappings: {e}")
+        return {}, {}
+
+receiver_to_player_id, passer_to_player_id = load_player_mappings()
+receiver_choices = sorted(list(receiver_to_player_id.keys()))
+passer_choices = sorted(list(passer_to_player_id.keys()))
+
+# Stadium coordinates
+STADIUM_COORDS = {
+    "ARI": {"lat": 33.5276, "lon": -112.2626}, "ATL": {"lat": 33.7554, "lon": -84.4008},
+    "BAL": {"lat": 39.2780, "lon": -76.6227}, "BUF": {"lat": 42.7738, "lon": -78.7870},
+    "CAR": {"lat": 35.2258, "lon": -80.8528}, "CHI": {"lat": 41.8623, "lon": -87.6167},
+    "CIN": {"lat": 39.0954, "lon": -84.5160}, "CLE": {"lat": 41.5061, "lon": -81.6995},
+    "DAL": {"lat": 32.7473, "lon": -97.0945}, "DEN": {"lat": 39.7439, "lon": -105.0201},
+    "DET": {"lat": 42.3400, "lon": -83.0456}, "GB": {"lat": 44.5013, "lon": -88.0622},
+    "HOU": {"lat": 29.6847, "lon": -95.4107}, "IND": {"lat": 39.7601, "lon": -86.1639},
+    "JAX": {"lat": 30.3239, "lon": -81.6373}, "KC": {"lat": 39.0489, "lon": -94.4839},
+    "LV": {"lat": 36.0908, "lon": -115.1833}, "LAC": {"lat": 33.9535, "lon": -118.3390},
+    "LAR": {"lat": 33.9535, "lon": -118.3390}, "MIA": {"lat": 25.9580, "lon": -80.2389},
+    "MIN": {"lat": 44.9738, "lon": -93.2577}, "NE": {"lat": 42.0909, "lon": -71.2643},
+    "NO": {"lat": 29.9511, "lon": -90.0812}, "NYG": {"lat": 40.8128, "lon": -74.0742},
+    "NYJ": {"lat": 40.8128, "lon": -74.0742}, "PHI": {"lat": 39.9008, "lon": -75.1675},
+    "PIT": {"lat": 40.4468, "lon": -80.0158}, "SF": {"lat": 37.4032, "lon": -121.9698},
+    "SEA": {"lat": 47.5952, "lon": -122.3316}, "TB": {"lat": 27.9759, "lon": -82.5033},
+    "TEN": {"lat": 36.1665, "lon": -86.7713}, "WAS": {"lat": 38.9076, "lon": -76.8645}
+}
+
+def get_weather_forecast(home_team, game_datetime):
+    """Get weather forecast for a stadium at game time."""
+    coords = STADIUM_COORDS.get(home_team)
+    if not coords:
+        return None
+    
+    url = "https://api.open-meteo.com/v1/forecast"
+    params = {
+        "latitude": coords["lat"], "longitude": coords["lon"],
+        "hourly": "temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code",
+        "temperature_unit": "fahrenheit", "wind_speed_unit": "mph",
+        "timezone": "America/New_York"
+    }
+    
+    try:
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        hourly = data.get("hourly", {})
+        times = hourly.get("time", [])
+        
+        game_time_str = game_datetime.strftime("%Y-%m-%dT%H:%M")
+        closest_idx = 0
+        for i, time_str in enumerate(times):
+            if time_str >= game_time_str:
+                closest_idx = i
+                break
+        
+        temp = hourly["temperature_2m"][closest_idx]
+        humidity = hourly["relative_humidity_2m"][closest_idx]
+        wind = hourly["wind_speed_10m"][closest_idx]
+        weather_code = hourly["weather_code"][closest_idx]
+        
+        is_rain = weather_code in [51, 53, 55, 61, 63, 65, 80, 81, 82]
+        is_snow = weather_code in [71, 73, 75, 77, 85, 86]
+        is_clear = weather_code in [0, 1, 2]
+        
+        return {
+            "temp_f": temp, "humidity_pct": humidity, "wind_mph": wind,
+            "is_rain": int(is_rain), "is_snow": int(is_snow), "is_clear": int(is_clear)
+        }
+    except Exception as e:
+        print(f"Weather API error: {e}")
+        return None
+
+def get_game_info_espn(home_team, away_team, week):
+    """Get game time, spread, and total from ESPN API."""
+    result = {"game_datetime": None, "pregame_spread": 0, "pregame_total": 0}
+    
+    try:
+        for season_type in [2, 3]:
+            url = f"https://site.api.espn.com/apis/site/v2/sports/football/nfl/scoreboard?seasontype={season_type}&week={week}"
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            
+            for event in data.get('events', []):
+                competition = event.get('competitions', [{}])[0]
+                competitors = competition.get('competitors', [])
+                
+                if len(competitors) < 2:
+                    continue
+                
+                h_team = competitors[0]['team']['abbreviation']
+                a_team = competitors[1]['team']['abbreviation']
+                
+                if (h_team == home_team and a_team == away_team) or (h_team == away_team and a_team == home_team):
+                    actual_home = h_team
+                    actual_away = a_team
+                    teams_reversed = (actual_home != home_team)
+                    
+                    game_date_str = event.get('date')
+                    if game_date_str:
+                        result["game_datetime"] = datetime.fromisoformat(game_date_str.replace('Z', '+00:00'))
+                    
+                    odds_data = competition.get('odds', [])
+                    if odds_data and len(odds_data) > 0:
+                        odds = odds_data[0]
+                        spread = odds.get('spread')
+                        total = odds.get('overUnder')
+                        
+                        away_odds = odds.get('awayTeamOdds', {})
+                        home_odds = odds.get('homeTeamOdds', {})
+                        
+                        if teams_reversed:
+                            if away_odds.get('favorite'):
+                                result["pregame_spread"] = -float(spread) if spread is not None else 0
+                            elif home_odds.get('favorite'):
+                                result["pregame_spread"] = float(spread) if spread is not None else 0
+                            else:
+                                result["pregame_spread"] = 0
+                        else:
+                            if away_odds.get('favorite'):
+                                result["pregame_spread"] = float(spread) if spread is not None else 0
+                            elif home_odds.get('favorite'):
+                                result["pregame_spread"] = -float(spread) if spread is not None else 0
+                            else:
+                                result["pregame_spread"] = 0
+                        
+                        result["pregame_total"] = float(total) if total is not None else 0
+                    
+                    return result
+    except Exception as e:
+        print(f"ESPN API error: {e}")
+    
+    return result
+
+def get_all_game_data(home_team, away_team, week):
+    """Get complete game data: time, odds, and weather forecast."""
+    game_info = get_game_info_espn(home_team, away_team, week)
+    weather = None
+    if game_info["game_datetime"]:
+        weather = get_weather_forecast(home_team, game_info["game_datetime"])
+    
+    dome_teams = ["ARI", "ATL", "DAL", "DET", "HOU", "IND", "LV", "LAR", "LAC", "MIN", "NO"]
+    is_dome = home_team in dome_teams
+    
+    if weather:
+        game_data = {
+            "game_datetime": game_info["game_datetime"],
+            "pregame_spread": game_info["pregame_spread"],
+            "pregame_total": game_info["pregame_total"],
+            "temp_f": weather["temp_f"],
+            "humidity_pct": weather["humidity_pct"],
+            "wind_mph": weather["wind_mph"],
+            "is_dome": int(is_dome),
+            "is_rain": weather["is_rain"] if not is_dome else 0,
+            "is_snow": weather["is_snow"] if not is_dome else 0,
+            "is_clear": weather["is_clear"] if not is_dome else 0
+        }
+    else:
+        game_data = {
+            "game_datetime": game_info["game_datetime"],
+            "pregame_spread": game_info["pregame_spread"],
+            "pregame_total": game_info["pregame_total"],
+            "temp_f": 72 if is_dome else 70,
+            "humidity_pct": 50,
+            "wind_mph": 0 if is_dome else 5,
+            "is_dome": int(is_dome),
+            "is_rain": 0, "is_snow": 0,
+            "is_clear": 0 if is_dome else 1
+        }
+    
+    return game_data
+
+NFL_TEAMS = [
+    "ARI", "ATL", "BAL", "BUF", "CAR", "CHI", "CIN", "CLE",
+    "DAL", "DEN", "DET", "GB", "HOU", "IND", "JAX", "KC",
+    "LV", "LAC", "LAR", "MIA", "MIN", "NE", "NO", "NYG",
+    "NYJ", "PHI", "PIT", "SEA", "SF", "TB", "TEN", "WAS"
+]
+
+def predict_yards(model_input_dict, receiver_id, passer_id):
+    """Make yards prediction using the loaded model."""
+    if predictor is None:
+        return None, "Model not loaded"
+    
+    try:
+        input_df = pd.DataFrame([model_input_dict])
+        
+        if player_embeddings is not None:
+            input_df = input_df.merge(
+                player_embeddings,
+                left_on="receiver_player_id",
+                right_on="player_id",
+                how="left"
+            ).drop(columns=["player_id"], errors="ignore")
+            
+            emb_cols = [c for c in player_embeddings.columns if c.startswith("emb_")]
+            if input_df[emb_cols].isna().any().any():
+                mean_emb = player_embeddings[emb_cols].mean()
+                input_df[emb_cols] = input_df[emb_cols].fillna(mean_emb)
+        
+        yards = None
+        
+        try:
+            leaderboard = predictor.leaderboard(silent=True)
+            individual_models = leaderboard[~leaderboard['model'].str.contains('Ensemble', case=False, na=False)]
+            
+            if len(individual_models) > 0:
+                for idx, row in individual_models.iterrows():
+                    model_name = row['model']
+                    try:
+                        prediction = predictor.predict(input_df, model=model_name)
+                        yards = float(prediction.values[0])
+                        return yards, None
+                    except Exception:
+                        continue
+        except Exception:
+            pass
+        
+        try:
+            prediction = predictor.predict(input_df)
+            yards = float(prediction.values[0])
+            return yards, None
+        except Exception:
+            pass
+        
+        return None, "All prediction strategies failed."
+    except Exception as e:
+        return None, f"Prediction error: {str(e)}"
+
+def create_model_input_and_predict(home_team, away_team, receiver_on_home_team, 
+                                   receiver_name, passer_name, week, season):
+    """Create model input from user selections and make prediction."""
+    try:
+        receiver_team = home_team if receiver_on_home_team else away_team
+        opponent_team = away_team if receiver_on_home_team else home_team
+        
+        def normalize_name(name):
+            parts = name.strip().split()
+            if len(parts) == 0:
+                return ""
+            if len(parts) > 1:
+                first_initial = parts[0][0].upper() + "."
+                last_name = parts[-1]
+                return f"{first_initial}{last_name}"
+            return parts[0].title()
+
+        wr_key = normalize_name(receiver_name)
+        qb_key = normalize_name(passer_name)
+        
+        receiver_id = receiver_to_player_id.get(wr_key)
+        passer_id = passer_to_player_id.get(qb_key)
+
+        if receiver_id is None:
+            return f"Error: Could not find receiver '{wr_key}' in database"
+        if passer_id is None:
+            return f"Error: Could not find passer '{qb_key}' in database"
+
+        game_data = get_all_game_data(home_team, away_team, week)
+        
+        team_map = {
+            "ARI": 1, "ATL": 2, "BAL": 3, "BUF": 4, "CAR": 5, "CHI": 6, "CIN": 7, "CLE": 8,
+            "DAL": 9, "DEN": 10, "DET": 11, "GB": 12, "HOU": 13, "IND": 14, "JAX": 15, "KC": 16,
+            "LV": 17, "LAC": 18, "LAR": 19, "MIA": 20, "MIN": 21, "NE": 22, "NO": 23, "NYG": 24,
+            "NYJ": 25, "PHI": 26, "PIT": 27, "SEA": 28, "SF": 29, "TB": 30, "TEN": 31, "WAS": 32
+        }
+        
+        home_team_surface_map = {
+            "ARI": "grass", "ATL": "fieldturf", "BAL": "grass", "BUF": "fieldturf",
+            "CAR": "fieldturf", "CHI": "grass", "CIN": "fieldturf", "CLE": "grass",
+            "DAL": "fieldturf", "DEN": "grass", "DET": "fieldturf", "GB": "grass",
+            "HOU": "fieldturf", "IND": "fieldturf", "JAX": "grass", "KC": "grass",
+            "LV": "grass", "LAC": "fieldturf", "LAR": "fieldturf", "MIA": "grass",
+            "MIN": "fieldturf", "NE": "fieldturf", "NO": "fieldturf", "NYG": "fieldturf",
+            "NYJ": "fieldturf", "PHI": "grass", "PIT": "grass", "SF": "grass",
+            "SEA": "fieldturf", "TB": "grass", "TEN": "fieldturf", "WAS": "grass"
+        }
+        
+        surface_map = {
+            "a_turf": 1, "grass": 2, "sportturf": 3, 
+            "fieldturf": 4, "matrixturf": 5, "astroturf": 6, "0": 0
+        }
+
+        posteam_id = team_map.get(receiver_team, 0)
+        defteam_id = team_map.get(opponent_team, 0)
+        home_team_id = team_map.get(home_team, 0)
+        away_team_id = team_map.get(away_team, 0)
+        
+        surface_type = home_team_surface_map.get(home_team, "grass")
+        surface_id = surface_map.get(surface_type, 2)
+
+        model_input = {
+            "receiver_player_id": receiver_id,
+            "passer_player_id": passer_id,
+            "posteam": posteam_id,
+            "defteam": defteam_id,
+            "surface": surface_id,
+            "is_dome": game_data.get("is_dome", 0),
+            "is_rain": game_data.get("is_rain", 0),
+            "is_snow": game_data.get("is_snow", 0),
+            "is_clear": game_data.get("is_clear", 1),
+            "temp_f": game_data.get("temp_f", 70),
+            "humidity_pct": game_data.get("humidity_pct", 50),
+            "wind_mph": game_data.get("wind_mph", 5),
+            "pregame_spread": game_data.get("pregame_spread", 0),
+            "pregame_total": game_data.get("pregame_total", 0),
+            "home_team": home_team_id,
+            "away_team": away_team_id,
+        }
+        
+        predicted_yards, error = predict_yards(model_input, receiver_id, passer_id)
+        
+        if error:
+            prediction_text = f"Error: {error}"
+        elif predicted_yards is not None:
+            prediction_text = f"PREDICTED YARDS: {predicted_yards:.1f}"
+        else:
+            prediction_text = "Prediction unavailable"
+        
+        output = f"""
+{prediction_text}
+
+Game Information:
+   • Matchup: {away_team} @ {home_team} (Week {week}, {season})
+   • Game Time: {game_data.get('game_datetime', 'TBD - Game not scheduled yet')}
+   • Venue: {home_team} ({surface_type}, {'Indoor' if game_data.get('is_dome') else 'Outdoor'})
+
+Players:
+   • Receiver: {receiver_name} ({wr_key}) - ID: {receiver_id}
+   • Passer: {passer_name} ({qb_key}) - ID: {passer_id}
+   • Team: {receiver_team} vs {opponent_team}
+
+Weather Conditions:
+   • Temperature: {game_data.get('temp_f', 70)}°F
+   • Humidity: {game_data.get('humidity_pct', 50)}%
+   • Wind: {game_data.get('wind_mph', 5)} mph
+   • Conditions: {'Dome' if game_data.get('is_dome') else 'Rain' if game_data.get('is_rain') else 'Snow' if game_data.get('is_snow') else 'Clear'}
+
+Betting Lines:
+   • Spread: {game_data.get('pregame_spread', 'N/A') if game_data.get('pregame_spread') != 0 else 'Not available yet'}
+   • Total: {game_data.get('pregame_total', 'N/A') if game_data.get('pregame_total') != 0 else 'Not available yet'}
+"""
+        
+        return output
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+with gr.Blocks(title="NFL Receiver Yards Predictor", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# NFL Receiver Yards Predictor")
+    gr.Markdown("Predict receiving yards with AI-powered analysis using weather, odds, and player data.")
+    
+    with gr.Row():
+        with gr.Column():
+            home_team = gr.Dropdown(choices=NFL_TEAMS, label="Home Team", value="JAX")
+            away_team = gr.Dropdown(choices=NFL_TEAMS, label="Away Team", value="KC")
+            
+        with gr.Column():
+            week = gr.Number(label="Week", value=5, precision=0)
+            season = gr.Number(label="Season", value=2024, precision=0)
+    
+    receiver_on_home = gr.Checkbox(label="Receiver is on Home Team", value=True)
+    
+    with gr.Row():
+        with gr.Column():
+            receiver_name = gr.Dropdown(choices=receiver_choices, label="Receiver Name", value="")
+        with gr.Column():
+            passer_name = gr.Dropdown(choices=passer_choices, label="Passer Name", value="")
+    
+    predict_btn = gr.Button("Predict Yards", variant="primary", size="lg")
+    
+    output = gr.Textbox(label="Prediction Results", lines=20, max_lines=25)
+    
+    predict_btn.click(
+        fn=create_model_input_and_predict,
+        inputs=[home_team, away_team, receiver_on_home, receiver_name, passer_name, week, season],
+        outputs=output
+    )
+    
+    gr.Markdown("""
+    ### Instructions:
+    1. Select the home and away teams
+    2. Enter the week number and season
+    3. Check the box if the receiver plays for the home team
+    4. Select the receiver and passer from the dropdown
+    5. Click **"Predict Yards"** to get the prediction
+    
+    The app automatically fetches weather forecast, betting lines, and stadium information.
+    """)
+
+if __name__ == "__main__":
+    app.launch()