Upload folder using huggingface_hub

README.md

@@ -1,12 +1,140 @@
 ---
-title: Nba Performance Predictor
-emoji: 🌍
-colorFrom: yellow
+title: NBA Performance Predictor
+emoji: 🏀
+colorFrom: red
 colorTo: blue
 sdk: gradio
 sdk_version: 5.44.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# NBA Player Performance Predictor
+
+## Model Description
+
+This interactive web application predicts NBA player points per game (PPG) using machine learning. The model analyzes historical player statistics, lag features, and engineered metrics to make predictions.
+
+## Features
+
+- **Interactive Interface**: User-friendly sliders and inputs for player statistics
+- **Example Players**: Pre-loaded NBA stars (LeBron James, Stephen Curry, etc.)
+- **Real-time Predictions**: Instant predictions as you adjust parameters
+- **Player Categories**: Automatic classification (Role Player → Superstar)
+- **Mobile Friendly**: Works on phones, tablets, and desktops
+
+## How to Use
+
+1. **Input Current Season Stats**: Use sliders to set age, games played, minutes, etc.
+2. **Add Historical Data**: Enter previous season performance metrics
+3. **Select Position**: Choose the player's primary position
+4. **Get Prediction**: Click "🔮 Predict Performance" for instant results
+5. **Try Examples**: Use the example player buttons for quick testing
+
+## Model Details
+
+- **Task**: Regression (Predicting NBA player points per game)
+- **Method**: XGBoost with time-series features
+- **Features**: Age, games, minutes, shooting stats, historical performance
+- **Performance**: RMSE ~3-5 points per game, R² ~0.6-0.8
+
+## Key Features Used
+
+The model considers various factors:
+- **Basic Stats**: Age, Games, Minutes Played, Field Goals, etc.
+- **Historical Performance**: Previous season statistics
+- **Efficiency Metrics**: Points per minute, overall efficiency
+- **Position & Team**: Encoded categorical variables
+- **Trend Analysis**: Performance changes over time
+
+## Prediction Categories
+
+Based on predicted PPG:
+- 🔵 **Role Player**: < 8 PPG
+- 🟢 **Solid Contributor**: 8-15 PPG  
+- 🟡 **Good Scorer**: 15-20 PPG
+- 🟠 **Star Player**: 20-25 PPG
+- 🔴 **Superstar**: 25+ PPG
+
+## Example Players
+
+Try these pre-loaded examples:
+- **LeBron James (Prime)**: All-around superstar stats
+- **Stephen Curry (Peak)**: Elite shooting guard numbers
+- **Rookie Player**: Typical first-year player stats
+- **Veteran Role Player**: Experienced bench contributor
+
+## Technical Implementation
+
+- **Frontend**: Gradio for interactive web interface
+- **Backend**: Python with XGBoost, scikit-learn, pandas
+- **Deployment**: Hugging Face Spaces
+- **Fallback Mode**: Simple heuristic when ML model unavailable
+
+## Limitations
+
+- Works best for players with NBA history (lag features required)
+- May be less accurate for rookies or players with significant role changes
+- Predictions based on historical patterns, may not account for injuries or major team changes
+- Current version runs in fallback mode (simplified predictions)
+
+## Future Improvements
+
+- Full XGBoost model integration
+- Additional statistics (advanced metrics, team context)
+- Multi-target prediction (rebounds, assists, efficiency)
+- Player comparison features
+- Historical trend visualization
+
+## Usage Examples
+
+### Basic Prediction
+```python
+# Example input for a typical NBA player
+player_stats = {
+    'age': 27,
+    'games': 75,
+    'minutes': 32.0,
+    'field_goal_pct': 45.0,
+    'position': 'Small Forward',
+    'pts_last_season': 18.5
+}
+```
+
+### Star Player Example
+```python
+# Example for elite player
+star_stats = {
+    'age': 28,
+    'games': 79,
+    'minutes': 36.0,
+    'field_goal_pct': 50.0,
+    'position': 'Point Guard',
+    'pts_last_season': 28.5
+}
+```
+
+## Data Sources
+
+The model was trained on historical NBA player statistics including:
+- Regular season performance data
+- Multiple seasons for trend analysis
+- Various player positions and team contexts
+
+## Ethical Considerations
+
+This model is for educational and analytical purposes only. It should not be used for:
+- Player salary negotiations without additional context
+- Draft decisions as the sole determining factor
+- Any form of discrimination or bias in player evaluation
+
+## Contact & Feedback
+
+Feel free to provide feedback or suggestions for improvements. This is an educational project demonstrating machine learning applications in sports analytics.
+
+---
+
+**Live Demo**: Try the interactive interface above!  
+**Status**: Currently running in fallback mode (simplified predictions)  
+**Next Update**: Full XGBoost model integration for enhanced accuracy

app.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+"""
+Gradio App for NBA Performance Predictor on Hugging Face Spaces
+"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import os
+import sys
+
+# Initialize the model
+MODEL_DIR = "nba_model"
+model = None
+model_error = None
+
+try:
+    # Try to import the huggingface model
+    from huggingface_model import NBAPerformancePredictorHF
+    
+    if os.path.exists(MODEL_DIR):
+        model = NBAPerformancePredictorHF(MODEL_DIR)
+        print("✅ Model loaded successfully!")
+    else:
+        model_error = f"Model directory '{MODEL_DIR}' not found. Please upload the trained model."
+        print(f"⚠️ {model_error}")
+except ImportError as e:
+    model_error = f"Cannot import huggingface_model: {e}"
+    print(f"❌ {model_error}")
+except Exception as e:
+    model_error = f"Error loading model: {e}"
+    print(f"❌ {model_error}")
+
+# Fallback prediction function if model fails to load
+def simple_prediction_fallback(pts_last_season, age, minutes_played):
+    """Simple fallback prediction when model is not available"""
+    # Basic heuristic based on age and last season performance
+    age_factor = 1.0 if age <= 27 else (0.95 if age <= 32 else 0.9)
+    minutes_factor = min(minutes_played / 35.0, 1.0)  # Normalize to 35 minutes
+    
+    prediction = pts_last_season * age_factor * minutes_factor
+    return max(prediction, 0.0)  # Ensure non-negative
+
+def predict_player_performance(
+    age, games, games_started, minutes_played, field_goals, field_goal_attempts,
+    field_goal_percentage, position, pts_last_season, pts_two_seasons_ago,
+    rebounds_last_season, assists_last_season, points_per_minute_last_season
+):
+    """
+    Predict NBA player performance based on input statistics
+    """
+    if model is None:
+        # Use fallback prediction
+        prediction = simple_prediction_fallback(pts_last_season, age, minutes_played)
+        
+        result_text = f"""
+🏀 **Predicted Points Per Game: {prediction:.1f}** *(Fallback Mode)*
+
+⚠️ **Note**: Using simplified prediction model because:
+{model_error}
+
+📊 **Input Summary:**
+- Player Age: {age}
+- Games: {games} (Started: {games_started})
+- Minutes per Game: {minutes_played:.1f}
+- Field Goal %: {field_goal_percentage:.1f}%
+- Position: {position}
+
+📈 **Historical Performance:**
+- Last Season PPG: {pts_last_season:.1f}
+- Two Seasons Ago PPG: {pts_two_seasons_ago:.1f}
+
+🔧 **Fallback Method**: Basic heuristic using age and last season performance
+        """
+        
+        # Performance category for fallback
+        if prediction < 8:
+            category = "🔵 Role Player (Estimated)"
+        elif prediction < 15:
+            category = "🟢 Solid Contributor (Estimated)"
+        elif prediction < 20:
+            category = "🟡 Good Scorer (Estimated)"
+        elif prediction < 25:
+            category = "🟠 Star Player (Estimated)"
+        else:
+            category = "🔴 Superstar (Estimated)"
+        
+        return result_text, category
+    
+    try:
+        # Position encoding (simplified)
+        position_encoding = {
+            "Point Guard": 0,
+            "Shooting Guard": 1,
+            "Small Forward": 2,
+            "Power Forward": 3,
+            "Center": 4
+        }
+        
+        # Age category encoding
+        age_category = 0 if age <= 23 else (1 if age <= 27 else (2 if age <= 32 else 3))
+        
+        # Create input dictionary
+        player_stats = {
+            'Age': age,
+            'G': games,
+            'GS': games_started,
+            'MP': minutes_played,
+            'FG': field_goals,
+            'FGA': field_goal_attempts,
+            'FG_1': field_goal_percentage / 100.0,  # Convert percentage to decimal
+            'Pos_encoded': position_encoding.get(position, 2),
+            'Team_encoded': 15,  # Default team encoding
+            'Age_category_encoded': age_category,
+            'PTS_lag_1': pts_last_season,
+            'PTS_lag_2': pts_two_seasons_ago,
+            'TRB_lag_1': rebounds_last_season,
+            'AST_lag_1': assists_last_season,
+            'Points_per_minute_lag_1': points_per_minute_last_season,
+            'Efficiency_lag_1': (pts_last_season + rebounds_last_season + assists_last_season) / minutes_played if minutes_played > 0 else 0
+        }
+        
+        # Make prediction
+        prediction = model.predict(player_stats)
+        
+        # Create detailed output
+        result_text = f"""
+🏀 **Predicted Points Per Game: {prediction:.1f}**
+
+📊 **Input Summary:**
+- Player Age: {age}
+- Games: {games} (Started: {games_started})
+- Minutes per Game: {minutes_played:.1f}
+- Field Goal %: {field_goal_percentage:.1f}%
+- Position: {position}
+
+📈 **Historical Performance:**
+- Last Season PPG: {pts_last_season:.1f}
+- Two Seasons Ago PPG: {pts_two_seasons_ago:.1f}
+- Last Season RPG: {rebounds_last_season:.1f}
+- Last Season APG: {assists_last_season:.1f}
+
+🎯 **Prediction Confidence:**
+{"High" if abs(prediction - pts_last_season) < 3 else "Medium" if abs(prediction - pts_last_season) < 6 else "Low"}
+        """
+        
+        # Performance category
+        if prediction < 8:
+            category = "🔵 Role Player"
+        elif prediction < 15:
+            category = "🟢 Solid Contributor"
+        elif prediction < 20:
+            category = "🟡 Good Scorer"
+        elif prediction < 25:
+            category = "🟠 Star Player"
+        else:
+            category = "🔴 Superstar"
+        
+        return result_text, category
+        
+    except Exception as e:
+        return f"❌ Error making prediction: {str(e)}", ""
+
+def load_example_player(player_name):
+    """Load example player data"""
+    examples = {
+        "LeBron James (Prime)": [27, 75, 75, 38.0, 9.5, 19.0, 50.0, "Small Forward", 27.1, 25.3, 7.4, 7.4, 0.71],
+        "Stephen Curry (Peak)": [28, 79, 79, 34.0, 10.2, 20.2, 50.4, "Point Guard", 30.1, 23.8, 5.4, 6.7, 0.88],
+        "Rookie Player": [22, 65, 15, 18.0, 3.2, 7.8, 41.0, "Shooting Guard", 8.5, 0.0, 2.8, 1.5, 0.47],
+        "Veteran Role Player": [32, 70, 25, 22.0, 4.1, 9.2, 44.6, "Power Forward", 11.2, 12.8, 5.2, 1.8, 0.51]
+    }
+    
+    if player_name in examples:
+        return examples[player_name]
+    return [25, 70, 50, 30.0, 6.0, 13.0, 46.0, "Small Forward", 15.0, 14.0, 5.0, 3.0, 0.50]
+
+# Create status message
+status_message = ""
+if model is None:
+    status_message = f"""
+    ⚠️ **Status**: Running in fallback mode
+    
+    **Issue**: {model_error}
+    
+    **Current Mode**: Using simplified prediction based on age and last season performance.
+    For full ML model predictions, ensure the trained model files are available.
+    """
+else:
+    status_message = "✅ **Status**: Full ML model loaded and ready!"
+
+# Create Gradio interface
+with gr.Blocks(title="NBA Performance Predictor", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(f"""
+    # 🏀 NBA Player Performance Predictor
+    
+    {status_message}
+    
+    Predict a player's points per game (PPG) using machine learning trained on historical NBA data.
+    
+    **How to use:**
+    1. Enter the player's current season statistics
+    2. Provide historical performance data (last 1-2 seasons)
+    3. Click "Predict Performance" to get the PPG prediction
+    
+    *Note: The model works best with players who have at least 1-2 seasons of NBA experience.*
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📋 Current Season Stats")
+            age = gr.Slider(18, 45, value=25, step=1, label="Age")
+            games = gr.Slider(1, 82, value=70, step=1, label="Games Played")
+            games_started = gr.Slider(0, 82, value=50, step=1, label="Games Started")
+            minutes_played = gr.Slider(5.0, 45.0, value=30.0, step=0.1, label="Minutes Per Game")
+            
+            with gr.Row():
+                field_goals = gr.Number(value=6.0, label="Field Goals Made Per Game")
+                field_goal_attempts = gr.Number(value=13.0, label="Field Goal Attempts Per Game")
+            
+            field_goal_percentage = gr.Slider(20.0, 70.0, value=46.0, step=0.1, label="Field Goal Percentage (%)")
+            position = gr.Dropdown(
+                choices=["Point Guard", "Shooting Guard", "Small Forward", "Power Forward", "Center"],
+                value="Small Forward",
+                label="Position"
+            )
+        
+        with gr.Column():
+            gr.Markdown("### 📈 Historical Performance")
+            pts_last_season = gr.Number(value=15.0, label="Points Per Game (Last Season)")
+            pts_two_seasons_ago = gr.Number(value=14.0, label="Points Per Game (Two Seasons Ago)")
+            rebounds_last_season = gr.Number(value=5.0, label="Rebounds Per Game (Last Season)")
+            assists_last_season = gr.Number(value=3.0, label="Assists Per Game (Last Season)")
+            points_per_minute_last_season = gr.Slider(0.1, 1.5, value=0.50, step=0.01, label="Points Per Minute (Last Season)")
+    
+    with gr.Row():
+        predict_btn = gr.Button("🔮 Predict Performance", variant="primary", size="lg")
+        clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+    
+    with gr.Row():
+        with gr.Column():
+            prediction_output = gr.Markdown(label="Prediction Result")
+        with gr.Column():
+            category_output = gr.Markdown(label="Player Category")
+    
+    # Example players section
+    gr.Markdown("### 👥 Try Example Players")
+    example_buttons = []
+    example_names = ["LeBron James (Prime)", "Stephen Curry (Peak)", "Rookie Player", "Veteran Role Player"]
+    
+    with gr.Row():
+        for name in example_names:
+            btn = gr.Button(name, variant="outline")
+            example_buttons.append(btn)
+    
+    # Event handlers
+    predict_btn.click(
+        fn=predict_player_performance,
+        inputs=[
+            age, games, games_started, minutes_played, field_goals, field_goal_attempts,
+            field_goal_percentage, position, pts_last_season, pts_two_seasons_ago,
+            rebounds_last_season, assists_last_season, points_per_minute_last_season
+        ],
+        outputs=[prediction_output, category_output]
+    )
+    
+    # Example player loading
+    for i, btn in enumerate(example_buttons):
+        btn.click(
+            fn=lambda name=example_names[i]: load_example_player(name),
+            outputs=[
+                age, games, games_started, minutes_played, field_goals, field_goal_attempts,
+                field_goal_percentage, position, pts_last_season, pts_two_seasons_ago,
+                rebounds_last_season, assists_last_season, points_per_minute_last_season
+            ]
+        )
+    
+    # Clear button
+    clear_btn.click(
+        fn=lambda: [25, 70, 50, 30.0, 6.0, 13.0, 46.0, "Small Forward", 15.0, 14.0, 5.0, 3.0, 0.50],
+        outputs=[
+            age, games, games_started, minutes_played, field_goals, field_goal_attempts,
+            field_goal_percentage, position, pts_last_season, pts_two_seasons_ago,
+            rebounds_last_season, assists_last_season, points_per_minute_last_season
+        ]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### ℹ️ About the Model
+    
+    - **Model Type**: XGBoost Regressor
+    - **Training Data**: Historical NBA player statistics
+    - **Performance**: RMSE ~3-5 points, R² ~0.6-0.8
+    - **Features**: Uses 50+ features including lag variables, rolling averages, and efficiency metrics
+    
+    **Limitations**: 
+    - Works best for players with NBA history
+    - May be less accurate for rookies or players with significant role changes
+    - Predictions are based on historical patterns and may not account for injuries or team changes
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

config.json

@@ -0,0 +1,49 @@
+{
+  "model_type": "xgboost",
+  "task": "regression",
+  "framework": "sklearn",
+  "target_variable": "PTS",
+  "model_name": "NBA Performance Predictor",
+  "version": "1.0.0",
+  "description": "XGBoost model for predicting NBA player points per game using historical statistics and time-series features",
+
+  "license": "MIT",
+  "tags": [
+    "xgboost",
+    "nba",
+    "sports-analytics",
+    "regression",
+    "time-series",
+    "basketball"
+  ],
+  "metrics": {
+    "rmse": "3-5 points",
+    "r2_score": "0.6-0.8"
+  },
+  "input_features": [
+    "Age",
+    "G",
+    "GS", 
+    "MP",
+    "FG",
+    "FGA",
+    "FG_1",
+    "Pos_encoded",
+    "Team_encoded",
+    "Age_category_encoded",
+    "PTS_lag_1",
+    "PTS_lag_2",
+    "TRB_lag_1",
+    "AST_lag_1",
+    "Points_per_minute_lag_1",
+    "Efficiency_lag_1"
+  ],
+  "preprocessing": {
+    "scaler": "StandardScaler",
+    "encodings": {
+      "position": "LabelEncoder",
+      "team": "LabelEncoder",
+      "age_category": "LabelEncoder"
+    }
+  }
+}

huggingface_model.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Compatible NBA Performance Predictor
+Description: Wrapper for NBA XGBoost model to work with Hugging Face Hub
+"""
+
+import os
+import json
+import numpy as np
+import pandas as pd
+import xgboost as xgb
+import joblib
+from typing import Dict, List, Union, Any
+from huggingface_hub import PyTorchModelHubMixin
+
+
+class NBAPerformancePredictorHF(PyTorchModelHubMixin):
+    """
+    Hugging Face compatible NBA Performance Predictor using XGBoost
+    """
+    
+    def __init__(self, model_dir: str = None, **kwargs):
+        """
+        Initialize the Hugging Face compatible model
+        
+        Args:
+            model_dir (str): Directory containing the saved model files
+        """
+        super().__init__()
+        self.model = None
+        self.scaler = None
+        self.feature_names = None
+        self.target_column = 'PTS'
+        self.model_metadata = {}
+        
+        if model_dir and os.path.exists(model_dir):
+            self.load_model(model_dir)
+    
+    def load_model(self, model_dir: str):
+        """
+        Load the saved XGBoost model and preprocessing components
+        
+        Args:
+            model_dir (str): Directory containing the saved model files
+        """
+        # Load metadata
+        metadata_path = os.path.join(model_dir, "model_metadata.json")
+        if os.path.exists(metadata_path):
+            with open(metadata_path, 'r') as f:
+                self.model_metadata = json.load(f)
+            
+            self.feature_names = self.model_metadata.get('feature_names', [])
+            self.target_column = self.model_metadata.get('target_column', 'PTS')
+        
+        # Load the XGBoost model
+        model_path = os.path.join(model_dir, "xgboost_model.json")
+        if os.path.exists(model_path):
+            self.model = xgb.XGBRegressor()
+            self.model.load_model(model_path)
+        
+        # Load the scaler
+        scaler_path = os.path.join(model_dir, "scaler.joblib")
+        if os.path.exists(scaler_path):
+            self.scaler = joblib.load(scaler_path)
+        
+        print(f"Model loaded successfully from {model_dir}/")
+    
+    def predict(self, player_stats: Union[Dict, List[Dict]]) -> Union[float, List[float]]:
+        """
+        Make predictions for NBA player performance
+        
+        Args:
+            player_stats: Dictionary or list of dictionaries with player statistics
+            
+        Returns:
+            Predicted points per game (float or list of floats)
+        """
+        if self.model is None:
+            raise ValueError("Model not loaded! Please load a trained model first.")
+        
+        # Handle single input
+        if isinstance(player_stats, dict):
+            player_stats = [player_stats]
+            single_input = True
+        else:
+            single_input = False
+        
+        predictions = []
+        
+        for stats in player_stats:
+            # Create DataFrame with the same structure as training data
+            input_df = pd.DataFrame([stats])
+            
+            # Ensure all required features are present
+            for feature in self.feature_names:
+                if feature not in input_df.columns:
+                    input_df[feature] = 0  # Default value for missing features
+            
+            # Select only the features used in training
+            input_df = input_df[self.feature_names]
+            
+            # Make prediction
+            prediction = self.model.predict(input_df)[0]
+            predictions.append(float(prediction))
+        
+        return predictions[0] if single_input else predictions
+    
+    def predict_batch(self, player_stats_list: List[Dict]) -> List[Dict]:
+        """
+        Make batch predictions with detailed output
+        
+        Args:
+            player_stats_list: List of player statistics dictionaries
+            
+        Returns:
+            List of prediction results with metadata
+        """
+        predictions = self.predict(player_stats_list)
+        
+        results = []
+        for i, (stats, pred) in enumerate(zip(player_stats_list, predictions)):
+            result = {
+                'input_id': i,
+                'predicted_points': round(pred, 2),
+                'player_name': stats.get('Player', f'Player_{i}'),
+                'confidence': 'high' if pred > 0 else 'low',  # Simple confidence measure
+                'input_features': len([k for k, v in stats.items() if v != 0])
+            }
+            results.append(result)
+        
+        return results
+    
+    def get_feature_info(self) -> Dict:
+        """
+        Get information about the features used by the model
+        
+        Returns:
+            Dictionary with feature information
+        """
+        return {
+            'total_features': len(self.feature_names) if self.feature_names else 0,
+            'feature_names': self.feature_names[:20] if self.feature_names else [],  # First 20
+            'target_variable': self.target_column,
+            'model_type': self.model_metadata.get('model_type', 'XGBRegressor'),
+            'required_features': [
+                'Age', 'G', 'GS', 'MP', 'FG', 'FGA', 'FG_1',
+                'Pos_encoded', 'Team_encoded', 'Age_category_encoded'
+            ]
+        }
+    
+    def create_example_input(self) -> Dict:
+        """
+        Create an example input for testing the model
+        
+        Returns:
+            Dictionary with example player statistics
+        """
+        return {
+            'Age': 27,
+            'G': 75,
+            'GS': 70,
+            'MP': 35.0,
+            'FG': 8.5,
+            'FGA': 18.0,
+            'FG_1': 0.472,
+            'Pos_encoded': 2,  # Forward
+            'Team_encoded': 15,
+            'Age_category_encoded': 1,  # Prime
+            'PTS_lag_1': 22.5,
+            'PTS_lag_2': 21.0,
+            'TRB_lag_1': 7.2,
+            'AST_lag_1': 4.8,
+            'Points_per_minute_lag_1': 0.64,
+            'Efficiency_lag_1': 1.0
+        }
+    
+    def _save_pretrained(self, save_directory: str, **kwargs):
+        """
+        Save the model for Hugging Face Hub (required by PyTorchModelHubMixin)
+        """
+        # Save the XGBoost model
+        model_path = os.path.join(save_directory, "xgboost_model.json")
+        if self.model:
+            self.model.save_model(model_path)
+        
+        # Save preprocessing components and metadata
+        if self.model_metadata:
+            metadata_path = os.path.join(save_directory, "model_metadata.json")
+            with open(metadata_path, 'w') as f:
+                json.dump(self.model_metadata, f, indent=2)
+        
+        # Save the scaler
+        if self.scaler:
+            scaler_path = os.path.join(save_directory, "scaler.joblib")
+            joblib.dump(self.scaler, scaler_path)
+        
+        print(f"Model saved to {save_directory}")
+    
+    def _from_pretrained(cls, *, model_id: str, revision: str, cache_dir: str, 
+                        force_download: bool, proxies: Dict, resume_download: bool,
+                        local_files_only: bool, token: str, **model_kwargs):
+        """
+        Load the model from Hugging Face Hub (required by PyTorchModelHubMixin)
+        """
+        return cls(model_dir=cache_dir, **model_kwargs)
+
+
+def create_model_card(model_dir: str = "nba_model", output_path: str = "README.md"):
+    """
+    Create a model card for Hugging Face Hub
+    
+    Args:
+        model_dir (str): Directory containing the model
+        output_path (str): Path to save the model card
+    """
+    model_card_content = """
+# NBA Player Performance Predictor
+
+## Model Description
+
+This model predicts NBA player points per game (PPG) using XGBoost regression with time-series features. The model uses historical player statistics, lag features, and engineered metrics to make predictions.
+
+## Model Details
+
+- **Model Type**: XGBoost Regressor
+- **Task**: Regression (Predicting NBA player points per game)
+- **Framework**: scikit-learn, XGBoost
+- **Performance**: RMSE ~3-5 points per game, R² ~0.6-0.8
+
+## Features
+
+The model uses various features including:
+- Basic stats: Age, Games, Minutes Played, Field Goals, etc.
+- Lag features: Previous season performance metrics
+- Rolling averages: 2-3 year performance averages
+- Efficiency metrics: Points per minute, overall efficiency
+- Categorical encodings: Position, Team, Age category
+
+## Usage
+
+```python
+from huggingface_model import NBAPerformancePredictorHF
+
+# Load the model
+model = NBAPerformancePredictorHF("path/to/model")
+
+# Example prediction
+player_stats = {
+    'Age': 27,
+    'G': 75,
+    'GS': 70,
+    'MP': 35.0,
+    'FG': 8.5,
+    'FGA': 18.0,
+    'FG_1': 0.472,
+    'Pos_encoded': 2,
+    'Team_encoded': 15,
+    'Age_category_encoded': 1,
+    'PTS_lag_1': 22.5,
+    'PTS_lag_2': 21.0,
+    'TRB_lag_1': 7.2,
+    'AST_lag_1': 4.8
+}
+
+predicted_points = model.predict(player_stats)
+print(f"Predicted PPG: {predicted_points:.2f}")
+```
+
+## Training Data
+
+The model was trained on NBA player statistics from multiple seasons, including:
+- Regular season statistics
+- Playoff performance data
+- Historical player performance trends
+
+## Limitations
+
+- Requires historical data (lag features) for accurate predictions
+- Performance may vary for rookie players or players with limited history
+- Model is trained on specific NBA eras and may need retraining for different time periods
+
+## Ethical Considerations
+
+This model is for educational and analytical purposes. It should not be used for:
+- Player salary negotiations
+- Draft decisions without additional context
+- Any form of discrimination or bias
+
+## Citation
+
+```
+@misc{nba_performance_predictor,
+  title={NBA Player Performance Predictor using XGBoost},
+  year={2024},
+  publisher={Hugging Face},
+  howpublished={\\url{https://huggingface.co/your-username/nba-performance-predictor}}
+}
+```
+"""
+    
+    with open(output_path, 'w') as f:
+        f.write(model_card_content)
+    
+    print(f"Model card created: {output_path}")
+
+
+if __name__ == "__main__":
+    # Example usage
+    print("NBA Performance Predictor - Hugging Face Compatible Version")
+    
+    # Create model instance (assumes model is already trained and saved)
+    model_dir = "nba_model"
+    if os.path.exists(model_dir):
+        model = NBAPerformancePredictorHF(model_dir)
+        
+        # Test prediction
+        example_stats = model.create_example_input()
+        prediction = model.predict(example_stats)
+        print(f"Example prediction: {prediction:.2f} PPG")
+        
+        # Get feature info
+        feature_info = model.get_feature_info()
+        print(f"Model uses {feature_info['total_features']} features")
+    else:
+        print(f"Model directory '{model_dir}' not found. Train the model first using nba_xgboost_predictor.py")

requirements.txt

@@ -0,0 +1,19 @@
+# Core ML dependencies
+pandas>=1.5.0
+numpy>=1.21.0
+scikit-learn>=1.1.0
+xgboost>=1.6.0
+joblib>=1.2.0
+
+# Hugging Face dependencies
+huggingface-hub>=0.17.0
+
+# Gradio for web interface
+gradio>=4.0.0
+
+# Visualization (optional for local development)
+matplotlib>=3.5.0
+seaborn>=0.11.0
+
+# Development dependencies (optional)
+jupyter>=1.0.0