Download app.py from triflix/NBA: direct link, hf CLI and curl.
- Browser
- Download file 17.1 kB
-
https://huggingface.co/spaces/triflix/NBA/resolve/main/app.py
- Command line
-
hf download hf://spaces/triflix/NBA/app.py
-
curl -L -o app.py https://huggingface.co/spaces/triflix/NBA/resolve/main/app.py
17.1 kB
| import gradio as gr | |
| import pickle | |
| import pandas as pd | |
| import numpy as np | |
| from sklearn.impute import SimpleImputer | |
| from sklearn.linear_model import LogisticRegression | |
| from sklearn.tree import DecisionTreeClassifier | |
| from sklearn.ensemble import BaggingClassifier, RandomForestClassifier | |
| from xgboost import XGBClassifier | |
| # --- Global Dictionaries & Lists --- | |
| LOADED_OBJECTS_LOGREG = {} | |
| LOADED_OBJECTS_TREE = {} | |
| MODEL_CACHE = {} | |
| logreg_ui_feature_order = [] | |
| tree_ui_feature_order = [] | |
| logreg_inputs_ui_components = [] | |
| tree_inputs_ui_components = [] | |
| # --- Default Sample Input Data --- | |
| # These should contain values for *all* features in their respective UI feature orders | |
| # For features that are often imputed, you can put a typical non-NaN value or np.nan if you want the default to show "blank then imputed" | |
| # (Gradio handles np.nan for gr.Number by showing it as blank) | |
| # Sample for Logistic Regression UI features | |
| # Keys should match elements in `logreg_ui_feature_order` | |
| DEFAULT_LOGREG_INPUTS = { | |
| 'AGE': 28, | |
| 'AVG_SPEED': 4.1, # Imputable | |
| 'DIST_MILES': 2.6, # Imputable | |
| 'DRIVE_FGA': 3.0, | |
| 'GP': 70, | |
| 'PACE': 99.5, | |
| 'PAINT_TOUCHES': 5.5, | |
| 'PLAYER_HEIGHT_INCHES': 78, # Imputable | |
| 'PLAYER_WEIGHT': 215, # Imputable | |
| 'POSS': 7100, | |
| 'PULL_UP_FG3A': 1.8 # Imputable | |
| # Add any other features that end up in logreg_ui_feature_order | |
| } | |
| # Sample for Tree Models UI features (this will be longer) | |
| # Keys should match elements in `tree_ui_feature_order` | |
| DEFAULT_TREE_INPUTS = { | |
| 'AGE': 26, | |
| 'PLAYER_HEIGHT_INCHES': 79, # Imputable | |
| 'PLAYER_WEIGHT': 220, # Imputable | |
| 'GP': 65, | |
| 'MIN': 32.0, | |
| 'USG_PCT': 0.22, | |
| 'PACE': 100.0, | |
| 'POSS': 7200, | |
| 'FGA_PG': 16.0, | |
| 'DRIVES': 11.0, | |
| 'DRIVE_FGA': 5.5, | |
| 'DRIVE_PASSES': 5.0, | |
| 'DIST_MILES': 2.7, # Imputable | |
| 'AVG_SPEED': 4.2, # Imputable | |
| 'PULL_UP_FGA': 5.5, | |
| 'PULL_UP_FG3A': 2.2, # Imputable | |
| 'TOUCHES': 65.0, | |
| 'FRONT_CT_TOUCHES': 33.0, | |
| 'AVG_SEC_PER_TOUCH': 2.8, | |
| 'AVG_DRIB_PER_TOUCH': 2.1, | |
| 'ELBOW_TOUCHES': 2.3, | |
| 'POST_TOUCHES': 3.5, | |
| 'PAINT_TOUCHES': 6.0 | |
| # Add all other features that are in tree_ui_feature_order | |
| } | |
| # --- Loading Functions (Modified to define UI feature orders earlier) --- | |
| def load_logreg_dependencies(): | |
| global logreg_ui_feature_order | |
| if not LOADED_OBJECTS_LOGREG: | |
| print("Loading Logistic Regression dependencies...") | |
| try: | |
| with open('simple_imputer_logreg.pkl', 'rb') as f: | |
| LOADED_OBJECTS_LOGREG['imputer'] = pickle.load(f) | |
| with open('cols_to_impute_logreg.pkl', 'rb') as f: | |
| LOADED_OBJECTS_LOGREG['cols_to_impute'] = pickle.load(f) | |
| with open('stepwise_features_logreg.pkl', 'rb') as f: | |
| LOADED_OBJECTS_LOGREG['features'] = pickle.load(f) | |
| with open('logisticregression.pkl', 'rb') as f: | |
| MODEL_CACHE['logistic_regression'] = pickle.load(f) | |
| _model_feats = LOADED_OBJECTS_LOGREG.get('features', []) | |
| _impute_cols = LOADED_OBJECTS_LOGREG.get('cols_to_impute', []) | |
| # All unique features needed for the UI, then sort for consistent order | |
| logreg_ui_feature_order = sorted(list(set(_model_feats + _impute_cols))) | |
| print("Logistic Regression dependencies loaded successfully.") | |
| print(f"LogReg UI features order set: {logreg_ui_feature_order}") | |
| return True | |
| except FileNotFoundError as e: # ... (rest of error handling) | |
| print(f"Error loading LogReg file: {e.filename}") | |
| gr.Warning(f"Required file for Logistic Regression not found: {e.filename}. This model will not work.") | |
| return False | |
| except Exception as e: | |
| print(f"Error loading LogReg dependencies: {e}") | |
| gr.Warning(f"Error loading dependencies for Logistic Regression: {e}") | |
| return False | |
| return True | |
| def load_tree_dependencies(): | |
| global tree_ui_feature_order | |
| if not LOADED_OBJECTS_TREE: | |
| print("Loading Tree-based model dependencies...") | |
| try: | |
| with open('simple_imputer_tree.pkl', 'rb') as f: | |
| LOADED_OBJECTS_TREE['imputer'] = pickle.load(f) | |
| with open('cols_to_impute_tree.pkl', 'rb') as f: | |
| LOADED_OBJECTS_TREE['cols_to_impute'] = pickle.load(f) | |
| with open('tree_model_feature_columns.pkl', 'rb') as f: | |
| LOADED_OBJECTS_TREE['features'] = pickle.load(f) | |
| tree_ui_feature_order = LOADED_OBJECTS_TREE['features'] | |
| tree_model_files = { # ... (model loading) | |
| "Optimized Decision Tree": "optimized_decision_tree_model.pkl", | |
| "Bagging Classifier": "bagging_classifier_model.pkl", | |
| "XGBoost Classifier": "xgboost_classifier_model.pkl", | |
| "Random Forest Classifier": "random_forest_classifier_model.pkl" | |
| } | |
| for name, path in tree_model_files.items(): | |
| with open(path, 'rb') as f: | |
| MODEL_CACHE[name.lower().replace(" ", "_")] = pickle.load(f) | |
| print("Tree-based model dependencies loaded successfully.") | |
| print(f"Tree UI features order set: {tree_ui_feature_order}") | |
| return True | |
| except FileNotFoundError as e: # ... (rest of error handling) | |
| print(f"Error loading Tree model file: {e.filename}") | |
| gr.Warning(f"Required file for Tree models not found: {e.filename}. Some tree models may not work.") | |
| return False | |
| except Exception as e: | |
| print(f"Error loading Tree dependencies: {e}") | |
| gr.Warning(f"Error loading dependencies for Tree models: {e}") | |
| return False | |
| return True | |
| LOGREG_READY = load_logreg_dependencies() | |
| TREE_READY = load_tree_dependencies() | |
| # --- Prediction Function (no changes needed here from the previous version for default values) --- | |
| def predict_injury(model_choice, *all_ui_values): | |
| # ... (Prediction function remains the same as the previous version) | |
| print(f"Model choice: {model_choice}") | |
| # all_ui_values contains values from logreg_inputs_ui_components then tree_inputs_ui_components | |
| raw_input_data = {} # This will hold {feature_name: value} for the chosen model's UI features | |
| if model_choice == "Logistic Regression": | |
| if not LOGREG_READY or 'logistic_regression' not in MODEL_CACHE: | |
| return "Logistic Regression model not loaded. Check logs.", "", "" | |
| num_logreg_ui_fields = len(logreg_ui_feature_order) | |
| current_args = all_ui_values[:num_logreg_ui_fields] | |
| current_ui_feature_order_for_dict_zip = logreg_ui_feature_order # Order of features as in UI | |
| imputer = LOADED_OBJECTS_LOGREG['imputer'] | |
| cols_to_impute_for_model = LOADED_OBJECTS_LOGREG['cols_to_impute'] | |
| final_model_features = LOADED_OBJECTS_LOGREG['features'] # Stepwise features | |
| model = MODEL_CACHE['logistic_regression'] | |
| raw_input_data = dict(zip(current_ui_feature_order_for_dict_zip, current_args)) | |
| elif model_choice in ["Optimized Decision Tree", "Bagging Classifier", "XGBoost Classifier", "Random Forest Classifier"]: | |
| if not TREE_READY or model_choice.lower().replace(" ", "_") not in MODEL_CACHE: | |
| return f"{model_choice} model not loaded. Check logs.", "", "" | |
| num_logreg_ui_fields = len(logreg_ui_feature_order) | |
| # num_tree_ui_fields = len(tree_ui_feature_order) # Not needed directly for slicing here | |
| current_args = all_ui_values[num_logreg_ui_fields:] # Get the rest of args for tree models | |
| current_ui_feature_order_for_dict_zip = tree_ui_feature_order # Order of features as in UI | |
| imputer = LOADED_OBJECTS_TREE['imputer'] | |
| cols_to_impute_for_model = LOADED_OBJECTS_TREE['cols_to_impute'] | |
| final_model_features = LOADED_OBJECTS_TREE['features'] # Full feature list | |
| model = MODEL_CACHE[model_choice.lower().replace(" ", "_")] | |
| raw_input_data = dict(zip(current_ui_feature_order_for_dict_zip, current_args)) | |
| else: | |
| return "Invalid model choice.", "", "" | |
| print(f"Raw input data mapped for model: {raw_input_data}") | |
| processed_values = {} | |
| for key, value in raw_input_data.items(): | |
| if isinstance(value, str) and value.strip() == "": | |
| processed_values[key] = np.nan | |
| elif value is None: # Gradio number input might return None if empty and no default | |
| processed_values[key] = np.nan | |
| else: | |
| try: | |
| processed_values[key] = float(value) | |
| except (ValueError, TypeError): | |
| if key not in cols_to_impute_for_model: | |
| return f"Invalid input for '{key}'. Please provide a number.", f"Error with input '{key}'", "" | |
| processed_values[key] = np.nan # Ensure it's np.nan for imputer | |
| df = pd.DataFrame([processed_values]) | |
| # Ensure df columns match the order expected by processing steps (usually current_ui_feature_order) | |
| # This ensures that when we select `cols_to_impute_for_model` or `final_model_features`, they exist. | |
| # We need to ensure all keys from current_ui_feature_order_for_dict_zip are columns in df | |
| df = df.reindex(columns=current_ui_feature_order_for_dict_zip) | |
| print("DataFrame before imputation:\n", df.head()) | |
| # Imputation | |
| try: | |
| imputable_cols_in_df = [col for col in cols_to_impute_for_model if col in df.columns] | |
| if imputable_cols_in_df: | |
| # Create a copy for transform to avoid SettingWithCopyWarning if df[imputable_cols_in_df] is a view | |
| df_subset_to_impute = df[imputable_cols_in_df].copy() | |
| transformed_subset = imputer.transform(df_subset_to_impute) | |
| df[imputable_cols_in_df] = transformed_subset | |
| print("DataFrame after imputation:\n", df.head()) | |
| except Exception as e: | |
| print(f"Error during imputation: {e}") | |
| return f"Error during data imputation: {e}", str(e), "" | |
| # Feature selection and ordering for the *final model input* | |
| try: | |
| final_df = df[final_model_features] | |
| print("Final DataFrame for model prediction:\n", final_df.head()) | |
| except KeyError as e: | |
| print(f"Error: Missing feature column for the model's final input: {e}") | |
| return f"Internal error: Missing expected feature {e}. Check model feature lists.", f"KeyError: {e}", "" | |
| except Exception as e: | |
| print(f"Error during final feature selection: {e}") | |
| return f"Error during data preparation: {e}", str(e), "" | |
| # Prediction | |
| try: | |
| pred_proba = model.predict_proba(final_df)[0] | |
| prediction = model.predict(final_df)[0] | |
| proba_injured = pred_proba[1] | |
| proba_not_injured = pred_proba[0] | |
| if prediction == 1: | |
| result_text = "Prediction: Likely Injured" | |
| probability_text = f"Probability of Injury: {proba_injured:.2%}\nProbability of No Injury: {proba_not_injured:.2%}" | |
| else: | |
| result_text = "Prediction: Likely Not Injured" | |
| probability_text = f"Probability of No Injury: {proba_not_injured:.2%}\nProbability of Injury: {proba_injured:.2%}" | |
| # Added a third output for more detailed info/status if needed | |
| return result_text, probability_text, "Prediction successful." | |
| except Exception as e: | |
| print(f"Error during prediction: {e}") | |
| return f"Error during prediction: {e}", str(e), "" | |
| # --- Create Gradio UI components with default values --- | |
| if LOGREG_READY and logreg_ui_feature_order: # Check if order is populated | |
| print(f"Generating UI components for LogReg with defaults. UI Features: {logreg_ui_feature_order}") | |
| for feature in logreg_ui_feature_order: | |
| label = feature.replace("_", " ").title() | |
| default_value = DEFAULT_LOGREG_INPUTS.get(feature, None) # Get default, or None | |
| if feature in LOADED_OBJECTS_LOGREG.get('cols_to_impute', []): | |
| label += " (can be blank for mean imputation)" | |
| logreg_inputs_ui_components.append( | |
| gr.Number(label=label, value=default_value, elem_id=f"logreg_{feature}") | |
| ) | |
| else: | |
| if not LOGREG_READY: print("Logistic Regression dependencies not loaded.") | |
| if not logreg_ui_feature_order: print("LogReg UI feature order not set.") | |
| if TREE_READY and tree_ui_feature_order: # Check if order is populated | |
| print(f"Generating UI components for Tree Models with defaults. UI Features: {tree_ui_feature_order}") | |
| for feature in tree_ui_feature_order: | |
| label = feature.replace("_", " ").title() | |
| default_value = DEFAULT_TREE_INPUTS.get(feature, None) | |
| if feature in LOADED_OBJECTS_TREE.get('cols_to_impute', []): | |
| label += " (can be blank for mean imputation)" | |
| tree_inputs_ui_components.append( | |
| gr.Number(label=label, value=default_value, elem_id=f"tree_{feature}") | |
| ) | |
| else: | |
| if not TREE_READY: print("Tree model dependencies not loaded.") | |
| if not tree_ui_feature_order: print("Tree UI feature order not set.") | |
| # --- Create Gradio Interface --- | |
| with gr.Blocks(theme=gr.themes.Soft()) as app: | |
| gr.Markdown("<h1>NBA Player Injury Predictor</h1>", elem_id="main_title") # Changed to h1 | |
| gr.Markdown("Select a model and enter player statistics. Fields are pre-filled with sample data. Adjust as needed. " | |
| "Blank fields for certain stats will be mean-imputed by the model.", elem_id="sub_title") | |
| model_choices = [] | |
| if LOGREG_READY and logreg_inputs_ui_components: model_choices.append("Logistic Regression") # Check if components were created | |
| if TREE_READY and tree_inputs_ui_components: model_choices.extend(["Optimized Decision Tree", "Bagging Classifier", "XGBoost Classifier", "Random Forest Classifier"]) | |
| if not model_choices: | |
| gr.Markdown("## CRITICAL ERROR: No models could be loaded or UI components generated. Check console logs.") | |
| else: | |
| model_selector = gr.Dropdown(choices=model_choices, label="Select Model", value=model_choices[0], elem_id="model_selector_dropdown") | |
| # Output components | |
| output_prediction = gr.Label(label="Prediction Result", elem_id="prediction_label") | |
| output_probability = gr.Textbox(label="Probabilities", lines=2, interactive=False, elem_id="probability_textbox") # Reduced lines | |
| # Optional status/debug message output | |
| output_status = gr.Textbox(label="Status", lines=1, interactive=False, elem_id="status_textbox", visible=False) # Initially hidden | |
| # Determine initial visibility based on the first choice | |
| initial_model_is_logreg = model_choices[0] == "Logistic Regression" | |
| with gr.Column(visible=initial_model_is_logreg, elem_id="logreg_inputs_column") as logreg_inputs_group: | |
| gr.Markdown("<h3>Logistic Regression Inputs</h3>", elem_id="logreg_header") # Changed to h3 | |
| if LOGREG_READY and logreg_inputs_ui_components: | |
| with gr.Accordion("Show/Hide Logistic Regression Stats", open=True): # Added Accordion | |
| for component in logreg_inputs_ui_components: | |
| component.render() | |
| else: | |
| gr.Markdown("*(Logistic Regression model failed to load or has no inputs defined)*") | |
| with gr.Column(visible=not initial_model_is_logreg, elem_id="tree_inputs_column") as tree_inputs_group: | |
| gr.Markdown("<h3>Tree-Based Model Inputs</h3>", elem_id="tree_header") # Changed to h3 | |
| if TREE_READY and tree_inputs_ui_components: | |
| with gr.Accordion("Show/Hide Tree Model Stats", open=True): # Added Accordion | |
| for component in tree_inputs_ui_components: | |
| component.render() | |
| else: | |
| gr.Markdown("*(Tree-based models failed to load or have no inputs defined)*") | |
| predict_button = gr.Button("Predict Injury", variant="primary", elem_id="predict_button_main") # Added variant | |
| def update_input_visibility(selected_model_value): | |
| is_logreg = selected_model_value == "Logistic Regression" | |
| return { # Return dict for gr.update | |
| logreg_inputs_group: gr.update(visible=is_logreg), | |
| tree_inputs_group: gr.update(visible=not is_logreg) | |
| } | |
| model_selector.change( | |
| fn=update_input_visibility, | |
| inputs=model_selector, | |
| outputs=[logreg_inputs_group, tree_inputs_group] | |
| ) | |
| all_ui_input_components_ordered = logreg_inputs_ui_components + tree_inputs_ui_components | |
| predict_button.click( | |
| fn=predict_injury, | |
| inputs=[model_selector] + all_ui_input_components_ordered, | |
| # predict_injury now returns 3 values, last one is status | |
| outputs=[output_prediction, output_probability, output_status] | |
| ) | |
| if __name__ == "__main__": | |
| if not model_choices: | |
| print("No models available. Gradio app may not function correctly.") | |
| app.launch() # show_error for better debugging |