Update app.py

app.py

@@ -1,56 +1,98 @@
 import gradio as gr
 import requests
+import json
+import ast
 import pandas as pd
 import os
+import pathlib, zipfile, shutil
 from datetime import datetime
-from huggingface_hub import snapshot_download
+from huggingface_hub import hf_hub_download, 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:
-        model_path = snapshot_download(
+        print(f"Downloading model from {repo_id}...")
+
+        # --- New Zip-Based Model Loading ---
+        ZIP_FILENAME = "autogluon_predictor_dir.zip"
+        CACHE_DIR = pathlib.Path(local_dir)
+        EXTRACT_DIR = CACHE_DIR / "predictor_native"
+
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        local_zip = hf_hub_download(
             repo_id=repo_id,
+            filename=ZIP_FILENAME,
             repo_type="model",
-            local_dir=local_dir,
-            local_dir_use_symlinks=False
+            local_dir=str(CACHE_DIR),
+            local_dir_use_symlinks=False,
         )
-        
-        model_dir = os.path.join(local_dir, "model")
-        predictor = TabularPredictor.load(model_dir, verbosity=0)
-        
-        emb_path = os.path.join(local_dir, "data", "player_historical_embeddings.csv")
+
+        if EXTRACT_DIR.exists():
+            shutil.rmtree(EXTRACT_DIR)
+        EXTRACT_DIR.mkdir(parents=True, exist_ok=True)
+
+        with zipfile.ZipFile(local_zip, "r") as zf:
+            zf.extractall(str(EXTRACT_DIR))
+
+        contents = list(EXTRACT_DIR.iterdir())
+        predictor_root = contents[0] if (len(contents) == 1 and contents[0].is_dir()) else EXTRACT_DIR
+
+        print(f"✓ Extracted model to: {predictor_root}")
+
+        predictor = TabularPredictor.load(predictor_root, require_py_version_match=False, verbosity=0)
+        print("✓ Successfully loaded AutoGluon predictor from zip")
+
+        # --- Download embeddings (same as before) ---
+        emb_path = os.path.join(local_dir, "player_historical_embeddings.csv")
         if not os.path.exists(emb_path):
-            emb_path = os.path.join(local_dir, "player_historical_embeddings.csv")
+            print(f"Downloading player embeddings from repo...")
+            snapshot_download(repo_id=repo_id, repo_type="model", local_dir=local_dir)
         
+        emb_path = os.path.join(local_dir, "data", "player_historical_embeddings.csv")
         emb_df = pd.read_csv(emb_path)
-        
+        print(f"✓ Loaded {len(emb_df)} player embeddings from {emb_path}")
+
         return predictor, emb_df
+
     except Exception as e:
+        import traceback
+        print(f"Error downloading model or embeddings: {e}")
+        traceback.print_exc()
         return None, None
 
+
 # Load model at startup
+print("Loading NFL Yards Prediction Model...")
 predictor, player_embeddings = download_model_and_embeddings()
 
+
 # Load player and game data
 try:
     players_df = pd.read_csv("players.csv")
     games_df = pd.read_csv("games.csv")
+    print(f"✓ Loaded {len(players_df)} players and {len(games_df)} games")
     
     # Create receiver and passer choices from players.csv
+    # Filter for receivers (WR, TE) and active players
     receivers_df = players_df[
         (players_df['position'].isin(['WR', 'TE'])) & 
         (players_df['status'] == 'ACT')
     ].copy()
     receiver_choices = sorted(receivers_df['display_name'].dropna().unique().tolist())
     
+    # Filter for quarterbacks
     passers_df = players_df[
         (players_df['position'] == 'QB') & 
         (players_df['status'] == 'ACT')
     ].copy()
     passer_choices = sorted(passers_df['display_name'].dropna().unique().tolist())
     
+    print(f"✓ Found {len(receiver_choices)} active receivers and {len(passer_choices)} active QBs")
+    
 except Exception as e:
+    print(f"⚠ Error loading player/game data: {e}")
     players_df = pd.DataFrame()
     games_df = pd.DataFrame()
     receiver_choices = []
@@ -76,13 +118,6 @@ STADIUM_COORDS = {
     "TEN": {"lat": 36.1665, "lon": -86.7713}, "WAS": {"lat": 38.9076, "lon": -76.8645}
 }
 
-def get_player_info(player_name, players_df):
-    """Get player's gsis_id, latest team, and headshot from display_name."""
-    player_row = players_df[players_df['display_name'] == player_name]
-    if player_row.empty:
-        return None, None, None
-    return player_row.iloc[0]['gsis_id'], player_row.iloc[0]['latest_team'], player_row.iloc[0].get('headshot', None)
-
 def update_receiver_image(receiver_name):
     """Update receiver headshot when selection changes."""
     if not receiver_name or players_df.empty:
@@ -96,6 +131,11 @@ def update_passer_image(passer_name):
         return None
     _, _, headshot = get_player_info(passer_name, players_df)
     return headshot
+    """Get player's gsis_id, latest team, and headshot from display_name."""
+    player_row = players_df[players_df['display_name'] == player_name]
+    if player_row.empty:
+        return None, None, None
+    return player_row.iloc[0]['gsis_id'], player_row.iloc[0]['latest_team'], player_row.iloc[0].get('headshot', None)
 
 def get_game_info(receiver_team, season, week, games_df):
     """Get game information based on receiver's team, season, and week."""
@@ -167,6 +207,7 @@ def get_weather_forecast(home_team, game_datetime):
             "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):
@@ -197,7 +238,7 @@ def get_game_info_espn(home_team, away_team, week):
                     return result
 
     except Exception as e:
-        pass
+        print(f"⚠ ESPN API error: {e}")
 
     return result
 
@@ -228,9 +269,16 @@ def predict_yards(model_input_dict, receiver_id, passer_id):
         }
         
         input_df = pd.DataFrame(input_data)
+        
+        print(f"Input DataFrame shape: {input_df.shape}")
+        print(f"Input DataFrame dtypes:\n{input_df.dtypes}")
+        print(f"Sample input:\n{input_df.head()}")
 
         # Merge player embeddings if available
         if player_embeddings is not None:
+            print(f"Merging embeddings for receiver: {receiver_id}")
+            
+            # Ensure player_id column in embeddings is string type for matching
             emb_df = player_embeddings.copy()
             emb_df['player_id'] = emb_df['player_id'].astype(str)
             
@@ -243,25 +291,45 @@ def predict_yards(model_input_dict, receiver_id, passer_id):
 
             emb_cols = [c for c in emb_df.columns if c.startswith("emb_")]
             if input_df[emb_cols].isna().any().any():
+                print(f"⚠ Missing embeddings for receiver {receiver_id}. Using global mean.")
                 mean_emb = emb_df[emb_cols].mean()
                 input_df[emb_cols] = input_df[emb_cols].fillna(mean_emb)
+            else:
+                print(f"✓ Found embeddings for receiver {receiver_id}")
+        else:
+            print("⚠ No embeddings loaded")
+
+        print(f"Final input shape: {input_df.shape}")
+        print(f"Final columns: {input_df.columns.tolist()}")
 
         # Make prediction
+        yards = None
+
         try:
+            print("Attempting prediction with full ensemble...")
             prediction = predictor.predict(input_df)
             yards = float(prediction.values[0])
+            print(f"✓ Success with full ensemble: {yards:.2f} yards")
             return yards, None
-        except Exception:
-            try:
-                leaderboard = predictor.leaderboard(silent=True)
-                best_model = leaderboard.iloc[0]['model']
-                prediction = predictor.predict(input_df, model=best_model)
-                yards = float(prediction.values[0])
-                return yards, None
-            except Exception:
-                return None, "Prediction failed"
-                
+        except Exception as pred_error:
+            print(f"✗ Full ensemble failed: {str(pred_error)[:100]}")
+
+        try:
+            print("Attempting prediction with best model only...")
+            leaderboard = predictor.leaderboard(silent=True)
+            best_model = leaderboard.iloc[0]['model']
+            print(f"Using best model: {best_model}")
+            prediction = predictor.predict(input_df, model=best_model)
+            yards = float(prediction.values[0])
+            print(f"✓ Success with best model: {yards:.2f} yards")
+            return yards, None
+        except Exception as best_error:
+            print(f"✗ Best model failed: {str(best_error)[:100]}")
+
+        return None, "All prediction strategies failed."
     except Exception as e:
+        import traceback
+        traceback.print_exc()
         return None, f"Prediction error: {str(e)}"
 
 def create_model_input_and_predict(receiver_name, passer_name, week, season):
@@ -270,17 +338,17 @@ def create_model_input_and_predict(receiver_name, passer_name, week, season):
         # Get receiver info from players.csv
         receiver_id, receiver_team, receiver_headshot = get_player_info(receiver_name, players_df)
         if receiver_id is None:
-            return "❌ Prediction Failed", f"Could not find receiver '{receiver_name}'", f"❌ Error: Could not find receiver '{receiver_name}' in database", None, None
+            return f"❌ Error: Could not find receiver '{receiver_name}' in database", None, None
 
         # Get passer info from players.csv
         passer_id, passer_team, passer_headshot = get_player_info(passer_name, players_df)
         if passer_id is None:
-            return "❌ Prediction Failed", f"Could not find passer '{passer_name}'", f"❌ Error: Could not find passer '{passer_name}' in database", None, None
+            return f"❌ Error: Could not find passer '{passer_name}' in database", None, None
 
         # Get game info from games.csv
         game_info = get_game_info(receiver_team, season, week, games_df)
         if game_info is None:
-            return "❌ Prediction Failed", "Game not found", f"❌ Error: Could not find game for {receiver_team} in Week {week} of {season} season", None, None
+            return f"❌ Error: Could not find game for {receiver_team} in Week {week} of {season} season"
 
         home_team = game_info['home_team']
         away_team = game_info['away_team']
@@ -340,6 +408,17 @@ def create_model_input_and_predict(receiver_name, passer_name, week, season):
             "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
@@ -350,9 +429,8 @@ def create_model_input_and_predict(receiver_name, passer_name, week, season):
         home_team_id = team_map.get(home_team, 0)
         away_team_id = team_map.get(away_team, 0)
 
-        # Get surface from games.csv
-        surface_type = game_info.get('surface', 'grass')
-        surface_id = surface_map.get(surface_type.lower() if surface_type else 'grass', 2)
+        surface_type = game_info.get('surface', home_team_surface_map.get(home_team, "grass"))
+        surface_id = surface_map.get(surface_type, 2)
 
         # Get betting lines from games.csv or default to 0
         pregame_spread = game_info.get('spread_line', 0) or 0
@@ -417,6 +495,8 @@ def create_model_input_and_predict(receiver_name, passer_name, week, season):
         return prediction_text, predicted_value, output, receiver_headshot, passer_headshot
 
     except Exception as e:
+        import traceback
+        traceback.print_exc()
         return "❌ Error", f"{str(e)}", f"❌ Error: {str(e)}", None, None
 
 # Create Gradio interface
@@ -475,21 +555,21 @@ with gr.Blocks(title="NFL Receiver Yards Predictor", theme=gr.themes.Soft()) as
     )
 
     gr.Markdown("""
-    ### 📋 How It Works:
-    1. **Select Receiver** → Headshot appears instantly
-    2. **Select Passer (QB)** → Headshot appears instantly  
-    3. **Enter Week & Season**
-    4. **Click "Predict Yards"** → Get your AI-powered prediction!
-
-    ### ⚡ What Happens Automatically:
-    - 🖼️ Player headshots load in real-time as you select them
-    - 🏟️ Determines matchup and venue based on receiver's team schedule
-    - 🌤️ Fetches live weather forecast for game time
-    - 💰 Loads betting lines (spread & total) from game data
-    - 🤖 Generates AI prediction using advanced machine learning model
-    - 📊 Displays comprehensive game analysis and prediction results
+    ### 📋 Instructions:
+    1. Select the receiver from the dropdown (headshot appears automatically)
+    2. Select the passer (QB) from the dropdown (headshot appears automatically)
+    3. Enter the week number and season
+    4. Click **"Predict Yards"** to get the prediction
+
+    The app will automatically:
+    - ✅ Display player headshots as you select them
+    - ✅ Determine which teams are playing based on the receiver's team
+    - ✅ Find the game in the schedule
+    - ✅ Fetch weather forecast for the game
+    - ✅ Load betting lines from historical data
+    - ✅ Generate AI-powered yards prediction
     """)
 
 # Launch the app
 if __name__ == "__main__":
-    app.launch()
+    app.launch(share=True, debug=True)