Upload 3 files

deployment/model/CalibrateLikelihood.ipynb

@@ -0,0 +1,389 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Calibrate Injury Likelihood Mapping\n",
+        "\n",
+        "This notebook calibrates the injury likelihood mapping for the injury risk prediction system. We use the training dataset (`Refined_Sports_Injury_Dataset.csv`) to map the model's predicted probabilities to true injury probabilities.\n",
+        "\n",
+        "## Objectives\n",
+        "- Load the dataset and trained models.\n",
+        "- Preprocess the data consistently with the training pipeline.\n",
+        "- Use the models to predict probabilities on a calibration set.\n",
+        "- Fit a logistic regression model to map predicted probabilities to true injury probabilities.\n",
+        "- Save the calibration model for use in `predict.py`."
+      ],
+      "metadata": {
+        "id": "v4eUbEr3u9Rm"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Import libraries\n",
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import joblib\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.linear_model import LogisticRegression\n",
+        "from sklearn.metrics import brier_score_loss\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# Set random seed\n",
+        "np.random.seed(42)"
+      ],
+      "metadata": {
+        "id": "Y_dhli46u9Ro"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 1. Load Data and Models ----------------------\n",
+        "# Load the dataset\n",
+        "data_path = \"/content/Refined_Sports_Injury_Dataset.csv\"\n",
+        "try:\n",
+        "    df = pd.read_csv(data_path)\n",
+        "except FileNotFoundError:\n",
+        "    raise FileNotFoundError(f\"Dataset file not found at {data_path}. Please ensure the file exists.\")\n",
+        "print(\"Dataset loaded. Shape:\", df.shape)\n",
+        "\n",
+        "# Load the trained models with error handling\n",
+        "model_dir = \"/content/model\"\n",
+        "try:\n",
+        "    rf_model = joblib.load(f\"{model_dir}/rf_injury_model.pkl\")\n",
+        "except Exception as e:\n",
+        "    raise FileNotFoundError(f\"Failed to load RandomForest model: {str(e)}. Ensure RandomForest.ipynb has been run successfully to generate {model_dir}/rf_injury_model.pkl.\")\n",
+        "\n",
+        "try:\n",
+        "    xgb_model = joblib.load(f\"{model_dir}/xgboost_injury_model.pkl\")\n",
+        "except Exception as e:\n",
+        "    raise FileNotFoundError(f\"Failed to load XGBoost model: {str(e)}. Ensure XGBOOST.ipynb has been run successfully to generate {model_dir}/xgboost_injury_model.pkl.\")\n",
+        "\n",
+        "print(\"Models loaded.\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NPDVk8WLu9Rp",
+        "outputId": "303e0a70-70b3-4796-d887-0b845c219e9a"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Dataset loaded. Shape: (10000, 18)\n",
+            "Models loaded.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 2. Preprocess Data ----------------------\n",
+        "# Encode categorical columns (consistent with training notebooks)\n",
+        "gender_mapping = {\"Male\": 0, \"Female\": 1}\n",
+        "experience_mapping = {\"Beginner\": 0, \"Intermediate\": 1, \"Advanced\": 2, \"Professional\": 3}\n",
+        "injury_type_mapping = {\"None\": 0, \"Sprain\": 1, \"Ligament Tear\": 2, \"Tendonitis\": 3, \"Strain\": 4, \"Fracture\": 5}\n",
+        "\n",
+        "# Handle NaN values in Previous_Injury_Type\n",
+        "df[\"Previous_Injury_Type\"] = df[\"Previous_Injury_Type\"].fillna(\"None\")\n",
+        "\n",
+        "df[\"Gender\"] = df[\"Gender\"].map(gender_mapping).fillna(0).astype(int)\n",
+        "df[\"Sport_Type\"] = df[\"Sport_Type\"].astype(\"category\").cat.codes\n",
+        "df[\"Experience_Level\"] = df[\"Experience_Level\"].map(experience_mapping).fillna(0).astype(int)\n",
+        "df[\"Previous_Injury_Type\"] = df[\"Previous_Injury_Type\"].map(injury_type_mapping).fillna(0).astype(int)\n",
+        "\n",
+        "# Replace 0 with 0.1 in Total_Weekly_Training_Hours\n",
+        "df[\"Total_Weekly_Training_Hours\"] = df[\"Total_Weekly_Training_Hours\"].replace(0, 0.1)\n",
+        "\n",
+        "# Create derived features\n",
+        "df[\"Intensity_Ratio\"] = df[\"High_Intensity_Training_Hours\"] / df[\"Total_Weekly_Training_Hours\"]\n",
+        "df[\"Recovery_Per_Training\"] = df[\"Recovery_Time_Between_Sessions\"] / df[\"Total_Weekly_Training_Hours\"]\n",
+        "\n",
+        "# Create Injury_Occurred column probabilistically based on Injury_Risk_Level\n",
+        "print(\"Injury_Risk_Level distribution:\\n\", df[\"Injury_Risk_Level\"].value_counts())\n",
+        "\n",
+        "# Define probabilities of injury occurrence based on risk level\n",
+        "injury_probabilities = {\n",
+        "    \"High\": 0.95,  # 95% chance of injury\n",
+        "    \"Medium\": 0.5, # 50% chance of injury\n",
+        "    \"Low\": 0.05    # 5% chance of injury\n",
+        "}\n",
+        "\n",
+        "# Generate Injury_Occurred using random sampling based on Injury_Risk_Level\n",
+        "df[\"Injury_Occurred\"] = df[\"Injury_Risk_Level\"].apply(\n",
+        "    lambda x: np.random.binomial(1, injury_probabilities[x])\n",
+        ")\n",
+        "\n",
+        "# Check the distribution of Injury_Occurred\n",
+        "print(\"Injury_Occurred distribution (full dataset):\\n\", df[\"Injury_Occurred\"].value_counts())\n",
+        "\n",
+        "# Ensure both classes are present\n",
+        "if len(df[\"Injury_Occurred\"].unique()) < 2:\n",
+        "    raise ValueError(\"Injury_Occurred contains only one class after probabilistic assignment. Adjust probabilities or dataset.\")\n",
+        "\n",
+        "# Define features\n",
+        "features = [\n",
+        "    \"Age\", \"Gender\", \"Sport_Type\", \"Experience_Level\", \"Flexibility_Score\",\n",
+        "    \"Total_Weekly_Training_Hours\", \"High_Intensity_Training_Hours\", \"Strength_Training_Frequency\",\n",
+        "    \"Recovery_Time_Between_Sessions\", \"Training_Load_Score\", \"Sprint_Speed\", \"Endurance_Score\",\n",
+        "    \"Agility_Score\", \"Fatigue_Level\", \"Previous_Injury_Count\", \"Previous_Injury_Type\",\n",
+        "    \"Intensity_Ratio\", \"Recovery_Per_Training\"\n",
+        "]\n",
+        "\n",
+        "# Prepare features and target\n",
+        "X = df[features]\n",
+        "y_outcome = df[\"Injury_Occurred\"]\n",
+        "\n",
+        "print(\"Features prepared:\", features)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rEUcpksxu9Rq",
+        "outputId": "70eee7a9-b2f5-4d3c-a668-504cd0c9dd81"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Injury_Risk_Level distribution:\n",
+            " Injury_Risk_Level\n",
+            "Medium    6016\n",
+            "Low       2827\n",
+            "High      1157\n",
+            "Name: count, dtype: int64\n",
+            "Injury_Occurred distribution (full dataset):\n",
+            " Injury_Occurred\n",
+            "0    5801\n",
+            "1    4199\n",
+            "Name: count, dtype: int64\n",
+            "Features prepared: ['Age', 'Gender', 'Sport_Type', 'Experience_Level', 'Flexibility_Score', 'Total_Weekly_Training_Hours', 'High_Intensity_Training_Hours', 'Strength_Training_Frequency', 'Recovery_Time_Between_Sessions', 'Training_Load_Score', 'Sprint_Speed', 'Endurance_Score', 'Agility_Score', 'Fatigue_Level', 'Previous_Injury_Count', 'Previous_Injury_Type', 'Intensity_Ratio', 'Recovery_Per_Training']\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 3. Split Data for Calibration ----------------------\n",
+        "# Split data into training and calibration sets\n",
+        "X_train, X_calib, y_train_outcome, y_calib_outcome = train_test_split(\n",
+        "    X, y_outcome, test_size=0.2, stratify=y_outcome, random_state=42\n",
+        ")\n",
+        "\n",
+        "print(\"Calibration set size:\", X_calib.shape)\n",
+        "print(\"Calibration Injury_Occurred distribution:\\n\", y_calib_outcome.value_counts())\n",
+        "\n",
+        "# Check if y_calib_outcome has both classes\n",
+        "if len(y_calib_outcome.unique()) < 2:\n",
+        "    raise ValueError(\"Calibration set contains only one class in Injury_Occurred. Cannot proceed with calibration.\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kbGVsNq4u9Rr",
+        "outputId": "732a5e13-f52b-4001-ee03-71a1b929fac7"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Calibration set size: (2000, 18)\n",
+            "Calibration Injury_Occurred distribution:\n",
+            " Injury_Occurred\n",
+            "0    1160\n",
+            "1     840\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 4. Predict Probabilities with Ensemble ----------------------\n",
+        "# Use the ensemble (average of RandomForest and XGBoost) to predict probabilities\n",
+        "rf_probs = rf_model.predict_proba(X_calib)\n",
+        "xgb_probs = xgb_model.predict_proba(X_calib)\n",
+        "\n",
+        "# Average the probabilities (same as in predict.py)\n",
+        "avg_probs = (rf_probs + xgb_probs) / 2\n",
+        "\n",
+        "# Get the predicted class and confidence\n",
+        "predicted_classes = np.argmax(avg_probs, axis=1)\n",
+        "confidences = np.max(avg_probs, axis=1)\n",
+        "\n",
+        "print(\"Sample of predicted confidences:\\n\", confidences[:5])\n",
+        "print(\"Sample of predicted classes:\\n\", predicted_classes[:5])\n",
+        "\n",
+        "# Inspect the relationship between predicted classes and Injury_Occurred\n",
+        "calib_df = pd.DataFrame({\n",
+        "    \"Predicted_Class\": predicted_classes,\n",
+        "    \"Injury_Occurred\": y_calib_outcome\n",
+        "})\n",
+        "print(\"Distribution of Injury_Occurred by Predicted Class:\\n\", calib_df.groupby(\"Predicted_Class\")[\"Injury_Occurred\"].value_counts())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "-Qyc_ZYOu9Rr",
+        "outputId": "10e3592e-c51c-49cb-9ff4-6e157701811e"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Sample of predicted confidences:\n",
+            " [0.98814357 0.9881264  0.97794891 0.97335743 0.97383904]\n",
+            "Sample of predicted classes:\n",
+            " [2 2 2 1 1]\n",
+            "Distribution of Injury_Occurred by Predicted Class:\n",
+            " Predicted_Class  Injury_Occurred\n",
+            "0                1                  216\n",
+            "                 0                   14\n",
+            "1                0                  540\n",
+            "                 1                   40\n",
+            "2                0                  606\n",
+            "                 1                  584\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 5. Map Probabilities to Injury Probabilities ----------------------\n",
+        "# Use the raw probabilities as features for calibration\n",
+        "calib_data = pd.DataFrame({\n",
+        "    \"prob_high\": avg_probs[:, 0],  # Probability of High risk\n",
+        "    \"prob_low\": avg_probs[:, 1],   # Probability of Low risk\n",
+        "    \"prob_medium\": avg_probs[:, 2] # Probability of Medium risk\n",
+        "})\n",
+        "\n",
+        "# Fit logistic regression with regularization\n",
+        "lr_calib = LogisticRegression(max_iter=1000, penalty='l2', C=1.0)\n",
+        "lr_calib.fit(calib_data, y_calib_outcome)\n",
+        "\n",
+        "# Predict calibrated probabilities\n",
+        "calibrated_probs = lr_calib.predict_proba(calib_data)[:, 1]\n",
+        "\n",
+        "# Evaluate calibration using Brier score\n",
+        "brier_score = brier_score_loss(y_calib_outcome, calibrated_probs)\n",
+        "print(f\"Brier Score (lower is better): {brier_score:.4f}\")\n",
+        "\n",
+        "# Inspect the mapping\n",
+        "calib_results = pd.DataFrame({\n",
+        "    \"Predicted_Class\": predicted_classes,\n",
+        "    \"Confidence\": confidences,\n",
+        "    \"Calibrated_Probability\": calibrated_probs,\n",
+        "    \"True_Injury_Occurred\": y_calib_outcome\n",
+        "})\n",
+        "print(\"Average Calibrated Probability by Predicted Class:\\n\", calib_results.groupby(\"Predicted_Class\")[\"Calibrated_Probability\"].mean())\n",
+        "\n",
+        "# Plot calibration curve\n",
+        "plt.figure(figsize=(8, 6))\n",
+        "plt.scatter(confidences, calibrated_probs, alpha=0.5)\n",
+        "plt.plot([0, 1], [0, 1], 'k--', label=\"Perfectly Calibrated\")\n",
+        "plt.xlabel(\"Original Confidence (Ensemble)\")\n",
+        "plt.ylabel(\"Calibrated Injury Probability (P(Injury_Occurred=1))\")\n",
+        "plt.title(\"Calibration Curve: Confidence vs. Injury Probability\")\n",
+        "plt.legend()\n",
+        "plt.savefig(f\"{model_dir}/calibration_curve.png\")\n",
+        "plt.close()\n",
+        "\n",
+        "print(f\"Calibration curve saved to {model_dir}/calibration_curve.png\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "oITFxyA4u9Rs",
+        "outputId": "98d1b529-b387-43ee-a7a8-9a7244701dd3"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Brier Score (lower is better): 0.1734\n",
+            "Average Calibrated Probability by Predicted Class:\n",
+            " Predicted_Class\n",
+            "0    0.923188\n",
+            "1    0.075402\n",
+            "2    0.490621\n",
+            "Name: Calibrated_Probability, dtype: float64\n",
+            "Calibration curve saved to /content/model/calibration_curve.png\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 6. Save Calibration Model ----------------------\n",
+        "# Save the logistic regression model for use in predict.py\n",
+        "import os\n",
+        "os.makedirs(model_dir, exist_ok=True)\n",
+        "joblib.dump(lr_calib, f\"{model_dir}/likelihood_calibrator.pkl\")\n",
+        "print(f\"Calibration model saved to {model_dir}/likelihood_calibrator.pkl\")\n",
+        "print(\"Note: You are running this in Google Colab. The file is saved to /content/model/likelihood_calibrator.pkl.\")\n",
+        "print(\"Please download it and move it to C:/Users/amrHa/Desktop/final 3/deployment/model/ for deployment.\")\n",
+        "print(\"Alternatively, if running locally, update model_dir to 'C:/Users/amrHa/Desktop/final 3/deployment/model'.\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "S8IY2YCZu9Rs",
+        "outputId": "4585d640-eb1b-49d2-ec60-2727704b2de5"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Calibration model saved to /content/model/likelihood_calibrator.pkl\n",
+            "Note: You are running this in Google Colab. The file is saved to /content/model/likelihood_calibrator.pkl.\n",
+            "Please download it and move it to C:/Users/amrHa/Desktop/final 3/deployment/model/ for deployment.\n",
+            "Alternatively, if running locally, update model_dir to 'C:/Users/amrHa/Desktop/final 3/deployment/model'.\n"
+          ]
+        }
+      ]
+    }
+  ]
+}

deployment/model/RandomForest.ipynb

@@ -0,0 +1,637 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zh2cG0-8e5J3"
+      },
+      "source": [
+        "# RandomForest Model for Injury Risk Prediction\n",
+        "\n",
+        "This notebook trains a RandomForest model to predict injury risk levels (Low, Medium, High) for athletes based on their training and physical attributes. The pipeline includes data loading, preprocessing, feature engineering, model training with hyperparameter tuning, probability calibration, evaluation, and testing.\n",
+        "\n",
+        "## Objectives\n",
+        "- Load and preprocess the dataset.\n",
+        "- Perform feature engineering to create meaningful features.\n",
+        "- Train a RandomForest model with optimized hyperparameter tuning.\n",
+        "- Calibrate probabilities to ensure reliable confidence scores.\n",
+        "- Evaluate the model using appropriate metrics and visualizations.\n",
+        "- Save the model and encoder for use in the prediction pipeline.\n",
+        "- Test the saved model on the test set or new data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9mkm6h_OfNaL",
+        "outputId": "536d54a0-46b7-4e91-fb9e-208fb1aa0983"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Requirement already satisfied: scikit-learn==1.6.1 in /usr/local/lib/python3.11/dist-packages (1.6.1)\n",
+            "Requirement already satisfied: joblib in /usr/local/lib/python3.11/dist-packages (1.4.2)\n",
+            "Requirement already satisfied: imbalanced-learn in /usr/local/lib/python3.11/dist-packages (0.12.4)\n",
+            "Requirement already satisfied: numpy>=1.19.5 in /usr/local/lib/python3.11/dist-packages (from scikit-learn==1.6.1) (2.0.2)\n",
+            "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn==1.6.1) (1.14.1)\n",
+            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn==1.6.1) (3.6.0)\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Install required packages\n",
+        "!pip install -U scikit-learn==1.6.1 joblib imbalanced-learn"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "zh2cG0-8e5J3"
+      },
+      "outputs": [],
+      "source": [
+        "# Import libraries\n",
+        "import os\n",
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import joblib\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "import random\n",
+        "from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold, RandomizedSearchCV\n",
+        "from sklearn.metrics import classification_report, confusion_matrix, f1_score, accuracy_score\n",
+        "from sklearn.ensemble import RandomForestClassifier\n",
+        "from imblearn.over_sampling import SMOTE\n",
+        "from sklearn.preprocessing import LabelEncoder\n",
+        "from sklearn.calibration import CalibratedClassifierCV\n",
+        "\n",
+        "# Set seed for reproducibility across all random processes\n",
+        "SEED = 42\n",
+        "np.random.seed(SEED)\n",
+        "random.seed(SEED)\n",
+        "os.environ['PYTHONHASHSEED'] = str(SEED)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lUBXg0QGe_19",
+        "outputId": "916a5487-cdca-45ed-b6f3-d330f258189f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loading dataset...\n",
+            "Dataset loaded. Shape: (10000, 18)\n",
+            "\n",
+            "Dataset Info:\n",
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 10000 entries, 0 to 9999\n",
+            "Data columns (total 18 columns):\n",
+            " #   Column                        Non-Null Count  Dtype  \n",
+            "---  ------                        --------------  -----  \n",
+            " 0   Age                           10000 non-null  int64  \n",
+            " 1   Gender                        10000 non-null  object \n",
+            " 2   Sport_Type                    10000 non-null  object \n",
+            " 3   Experience_Level              10000 non-null  object \n",
+            " 4   Flexibility_Score             10000 non-null  float64\n",
+            " 5   Total_Weekly_Training_Hours   10000 non-null  float64\n",
+            " 6   High_Intensity_Training_Hours 10000 non-null  float64\n",
+            " 7   Strength_Training_Frequency   10000 non-null  int64  \n",
+            " 8   Recovery_Time_Between_Sessions 10000 non-null  float64\n",
+            " 9   Training_Load_Score           10000 non-null  float64\n",
+            " 10  Sprint_Speed                  10000 non-null  float64\n",
+            " 11  Endurance_Score               10000 non-null  float64\n",
+            " 12  Agility_Score                 10000 non-null  float64\n",
+            " 13  Fatigue_Level                 10000 non-null  int64  \n",
+            " 14  Previous_Injury_Count         10000 non-null  int64  \n",
+            " 15  Previous_Injury_Type          10000 non-null  object \n",
+            " 16  Injury_Risk_Level             10000 non-null  object \n",
+            " 17  Injury_Outcome                10000 non-null  int64  \n",
+            "dtypes: float64(8), int64(5), object(5)\n",
+            "memory usage: 1.4+ MB\n",
+            "None\n",
+            "\n",
+            "Class Distribution:\n",
+            "Injury_Risk_Level\n",
+            "Medium    6014\n",
+            "Low       2832\n",
+            "High      1154\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 1. Load Data ----------------------\n",
+        "print(\"Loading dataset...\")\n",
+        "data_path = \"/content/Refined_Sports_Injury_Dataset.csv\"\n",
+        "\n",
+        "# Check if file exists\n",
+        "if not os.path.exists(data_path):\n",
+        "    raise FileNotFoundError(f\"Dataset file not found at {data_path}. Please ensure the file exists.\")\n",
+        "\n",
+        "df = pd.read_csv(data_path)\n",
+        "\n",
+        "# Validate dataset structure\n",
+        "expected_columns = [\n",
+        "    \"Age\", \"Gender\", \"Sport_Type\", \"Experience_Level\", \"Flexibility_Score\",\n",
+        "    \"Total_Weekly_Training_Hours\", \"High_Intensity_Training_Hours\", \"Strength_Training_Frequency\",\n",
+        "    \"Recovery_Time_Between_Sessions\", \"Training_Load_Score\", \"Sprint_Speed\", \"Endurance_Score\",\n",
+        "    \"Agility_Score\", \"Fatigue_Level\", \"Previous_Injury_Count\", \"Previous_Injury_Type\",\n",
+        "    \"Injury_Risk_Level\"\n",
+        "]\n",
+        "if not all(col in df.columns for col in expected_columns):\n",
+        "    missing_cols = [col for col in expected_columns if col not in df.columns]\n",
+        "    raise ValueError(f\"Dataset is missing required columns: {missing_cols}\")\n",
+        "\n",
+        "# Display dataset info\n",
+        "print(\"Dataset loaded. Shape:\", df.shape)\n",
+        "print(\"\\nDataset Info:\")\n",
+        "print(df.info())\n",
+        "print(\"\\nClass Distribution:\")\n",
+        "print(df[\"Injury_Risk_Level\"].value_counts())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5NyQ1yuhLLRW",
+        "outputId": "ab2a5946-d752-46ba-ea42-69df3e6d8c4a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "🔠 Encoding categorical columns...\n",
+            "Encoded class mapping: {'High': 0, 'Low': 1, 'Medium': 2}\n",
+            "Sample of encoded data:\n",
+            "    Age  Gender  Sport_Type  Experience_Level  Flexibility_Score  \\\n",
+            "0   34       0           2                 0                7.2   \n",
+            "1   29       1           4                 3                8.5   \n",
+            "2   31       0           2                 2                6.8   \n",
+            "3   27       1           0                 1                7.9   \n",
+            "4   33       0           3                 2                6.5   \n",
+            "\n",
+            "   Total_Weekly_Training_Hours  High_Intensity_Training_Hours  \\\n",
+            "0                         12.0                            4.0   \n",
+            "1                          8.0                            2.0   \n",
+            "2                         15.0                            6.0   \n",
+            "3                         10.0                            3.0   \n",
+            "4                          9.0                            3.0   \n",
+            "\n",
+            "   Strength_Training_Frequency  Recovery_Time_Between_Sessions  \\\n",
+            "0                            3                            48.0   \n",
+            "1                            2                            72.0   \n",
+            "2                            4                            36.0   \n",
+            "3                            2                            60.0   \n",
+            "4                            3                            48.0   \n",
+            "\n",
+            "   Training_Load_Score  Sprint_Speed  Endurance_Score  Agility_Score  \\\n",
+            "0                 65.0           6.8              7.5            7.0   \n",
+            "1                 45.0           7.2              8.0            8.2   \n",
+            "2                 80.0           6.5              7.0            6.8   \n",
+            "3                 55.0           7.0              7.8            7.5   \n",
+            "4                 60.0           6.7              7.2            6.9   \n",
+            "\n",
+            "   Fatigue_Level  Previous_Injury_Count  Previous_Injury_Type  \\\n",
+            "0              4                      1                     1   \n",
+            "1              2                      0                     0   \n",
+            "2              6                      2                     2   \n",
+            "3              3                      0                     0   \n",
+            "4              5                      1                     3   \n",
+            "\n",
+            "   Injury_Risk_Level  Injury_Outcome  \n",
+            "0                  2               0  \n",
+            "1                  1               0  \n",
+            "2                  0               1  \n",
+            "3                  1               0  \n",
+            "4                  2               0  \n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 2. Data Preprocessing & Encoding ----------------------\n",
+        "print(\"\\n🔠 Encoding categorical columns...\")\n",
+        "\n",
+        "# Define mappings for categorical variables\n",
+        "gender_mapping = {\"Male\": 0, \"Female\": 1}\n",
+        "experience_mapping = {\"Beginner\": 0, \"Intermediate\": 1, \"Advanced\": 2, \"Professional\": 3}\n",
+        "injury_type_mapping = {\"None\": 0, \"Sprain\": 1, \"Ligament Tear\": 2, \"Tendonitis\": 3, \"Strain\": 4, \"Fracture\": 5}\n",
+        "\n",
+        "# Handle NaN values in Previous_Injury_Type by treating them as 'None'\n",
+        "df[\"Previous_Injury_Type\"] = df[\"Previous_Injury_Type\"].fillna(\"None\")\n",
+        "\n",
+        "# Validate categorical columns before encoding\n",
+        "for col, mapping in [(\"Gender\", gender_mapping), (\"Experience_Level\", experience_mapping), (\"Previous_Injury_Type\", injury_type_mapping)]:\n",
+        "    invalid_values = set(df[col]) - set(mapping.keys())\n",
+        "    if invalid_values:\n",
+        "        raise ValueError(f\"Invalid values found in {col}: {invalid_values}. Expected values: {list(mapping.keys())}\")\n",
+        "\n",
+        "# Encode Gender\n",
+        "df[\"Gender\"] = df[\"Gender\"].map(gender_mapping).fillna(0).astype(int)\n",
+        "\n",
+        "# Encode Sport_Type dynamically\n",
+        "df[\"Sport_Type\"] = df[\"Sport_Type\"].astype(\"category\").cat.codes\n",
+        "\n",
+        "# Encode Experience_Level\n",
+        "df[\"Experience_Level\"] = df[\"Experience_Level\"].map(experience_mapping).fillna(0).astype(int)\n",
+        "\n",
+        "# Encode Previous_Injury_Type\n",
+        "df[\"Previous_Injury_Type\"] = df[\"Previous_Injury_Type\"].map(injury_type_mapping).fillna(0).astype(int)\n",
+        "\n",
+        "# Encode target variable (Injury_Risk_Level)\n",
+        "le = LabelEncoder()\n",
+        "df[\"Injury_Risk_Level\"] = le.fit_transform(df[\"Injury_Risk_Level\"].astype(str))\n",
+        "\n",
+        "# Verify encoding\n",
+        "print(\"Encoded class mapping:\", dict(zip(le.classes_, range(len(le.classes_)))))\n",
+        "print(\"Sample of encoded data:\\n\", df.head())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Y4373JooLLit",
+        "outputId": "b9760f3d-3d2b-41b1-a63f-a6930099e0f7"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "🛠️ Creating derived features...\n",
+            "Features created: ['Age', 'Gender', 'Sport_Type', 'Experience_Level', 'Flexibility_Score', 'Total_Weekly_Training_Hours', 'High_Intensity_Training_Hours', 'Strength_Training_Frequency', 'Recovery_Time_Between_Sessions', 'Training_Load_Score', 'Sprint_Speed', 'Endurance_Score', 'Agility_Score', 'Fatigue_Level', 'Previous_Injury_Count', 'Previous_Injury_Type', 'Intensity_Ratio', 'Recovery_Per_Training']\n",
+            "Sample of features:\n",
+            "    Age  Gender  Sport_Type  Experience_Level  Flexibility_Score  \\\n",
+            "0   34       0           2                 0                7.2   \n",
+            "1   29       1           4                 3                8.5   \n",
+            "2   31       0           2                 2                6.8   \n",
+            "3   27       1           0                 1                7.9   \n",
+            "4   33       0           3                 2                6.5   \n",
+            "\n",
+            "   Total_Weekly_Training_Hours  High_Intensity_Training_Hours  \\\n",
+            "0                         12.0                            4.0   \n",
+            "1                          8.0                            2.0   \n",
+            "2                         15.0                            6.0   \n",
+            "3                         10.0                            3.0   \n",
+            "4                          9.0                            3.0   \n",
+            "\n",
+            "   Strength_Training_Frequency  Recovery_Time_Between_Sessions  \\\n",
+            "0                            3                            48.0   \n",
+            "1                            2                            72.0   \n",
+            "2                            4                            36.0   \n",
+            "3                            2                            60.0   \n",
+            "4                            3                            48.0   \n",
+            "\n",
+            "   Training_Load_Score  Sprint_Speed  Endurance_Score  Agility_Score  \\\n",
+            "0                 65.0           6.8              7.5            7.0   \n",
+            "1                 45.0           7.2              8.0            8.2   \n",
+            "2                 80.0           6.5              7.0            6.8   \n",
+            "3                 55.0           7.0              7.8            7.5   \n",
+            "4                 60.0           6.7              7.2            6.9   \n",
+            "\n",
+            "   Fatigue_Level  Previous_Injury_Count  Previous_Injury_Type  Intensity_Ratio  \\\n",
+            "0              4                      1                     1        0.333333   \n",
+            "1              2                      0                     0        0.250000   \n",
+            "2              6                      2                     2        0.400000   \n",
+            "3              3                      0                     0        0.300000   \n",
+            "4              5                      1                     3        0.333333   \n",
+            "\n",
+            "   Recovery_Per_Training  \n",
+            "0                    4.0  \n",
+            "1                    9.0  \n",
+            "2                    2.4  \n",
+            "3                    6.0  \n",
+            "4                    5.3  \n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 3. Feature Engineering ----------------------\n",
+        "print(\"\\n🛠️ Creating derived features...\")\n",
+        "\n",
+        "# Replace 0 with 0.1 in Total_Weekly_Training_Hours to avoid division by zero\n",
+        "df[\"Total_Weekly_Training_Hours\"] = df[\"Total_Weekly_Training_Hours\"].replace(0, 0.1)\n",
+        "\n",
+        "# Create derived features\n",
+        "df[\"Intensity_Ratio\"] = df[\"High_Intensity_Training_Hours\"] / df[\"Total_Weekly_Training_Hours\"]\n",
+        "df[\"Recovery_Per_Training\"] = df[\"Recovery_Time_Between_Sessions\"] / df[\"Total_Weekly_Training_Hours\"]\n",
+        "\n",
+        "# Check for NaN or infinite values in derived features\n",
+        "if df[[\"Intensity_Ratio\", \"Recovery_Per_Training\"]].isna().any().any() or np.isinf(df[[\"Intensity_Ratio\", \"Recovery_Per_Training\"]]).any().any():\n",
+        "    raise ValueError(\"NaN or infinite values found in derived features. Check data for inconsistencies.\")\n",
+        "\n",
+        "# Define features\n",
+        "features = [\n",
+        "    \"Age\", \"Gender\", \"Sport_Type\", \"Experience_Level\", \"Flexibility_Score\",\n",
+        "    \"Total_Weekly_Training_Hours\", \"High_Intensity_Training_Hours\", \"Strength_Training_Frequency\",\n",
+        "    \"Recovery_Time_Between_Sessions\", \"Training_Load_Score\", \"Sprint_Speed\", \"Endurance_Score\",\n",
+        "    \"Agility_Score\", \"Fatigue_Level\", \"Previous_Injury_Count\", \"Previous_Injury_Type\",\n",
+        "    \"Intensity_Ratio\", \"Recovery_Per_Training\"\n",
+        "]\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Prepare features and target\n",
+        "X = df[features]\n",
+        "y = df[\"Injury_Risk_Level\"]\n",
+        "\n",
+        "# Verify features\n",
+        "print(\"Features created:\", features)\n",
+        "print(\"Sample of features:\\n\", X.head())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "MORGKXZULLsQ",
+        "outputId": "8c993957-7909-400b-a311-eab5fda2127b"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "📊 Splitting data & applying SMOTE...\n",
+            "Training set class distribution after SMOTE:\n",
+            "0    4811\n",
+            "1    4811\n",
+            "2    4811\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 4. Train/Test Split & SMOTE ----------------------\n",
+        "print(\"\\n📊 Splitting data & applying SMOTE...\")\n",
+        "\n",
+        "# Split data into train and test sets\n",
+        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=SEED)\n",
+        "\n",
+        "# Apply SMOTE to balance the training set\n",
+        "try:\n",
+        "    sm = SMOTE(random_state=SEED)\n",
+        "    X_train_res, y_train_res = sm.fit_resample(X_train, y_train)\n",
+        "except Exception as e:\n",
+        "    raise RuntimeError(f\"SMOTE failed: {str(e)}. Check for invalid data in X_train or y_train.\")\n",
+        "\n",
+        "# Print class distribution after SMOTE\n",
+        "print(\"Training set class distribution after SMOTE:\")\n",
+        "print(pd.Series(y_train_res).value_counts())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "sKycZa1YLL11",
+        "outputId": "94940989-75fe-4cae-aee9-908a26d63bc1"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "🔍 Performing hyperparameter tuning...\n",
+            "Best hyperparameters: {'n_estimators': 300, 'min_samples_split': 2, 'min_samples_leaf': 1, 'max_depth': 25}\n",
+            "Best cross-validation F1-score: 0.947693499624901\n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 5. Hyperparameter Tuning with RandomizedSearchCV ----------------------\n",
+        "print(\"\\n🔍 Performing hyperparameter tuning...\")\n",
+        "\n",
+        "# Compute class weights to prioritize 'High' class\n",
+        "class_weights = {0: 2.0, 1: 1.0, 2: 1.0}  # Higher weight for 'High' (encoded as 0)\n",
+        "\n",
+        "# Define RandomForest model\n",
+        "rf = RandomForestClassifier(random_state=SEED, class_weight=class_weights)\n",
+        "\n",
+        "# Define reduced hyperparameter grid for faster tuning\n",
+        "param_dist = {\n",
+        "    'n_estimators': [100, 200, 300],\n",
+        "    'max_depth': [15, 20, 25],\n",
+        "    'min_samples_split': [2, 5],\n",
+        "    'min_samples_leaf': [1, 2]\n",
+        "}\n",
+        "\n",
+        "# Perform randomized search with cross-validation\n",
+        "cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)\n",
+        "random_search = RandomizedSearchCV(\n",
+        "    estimator=rf, param_distributions=param_dist, n_iter=15, cv=cv,\n",
+        "    scoring='f1_macro', n_jobs=1, random_state=SEED\n",
+        ")\n",
+        "random_search.fit(X_train_res, y_train_res)\n",
+        "\n",
+        "# Get best model\n",
+        "best_rf = random_search.best_estimator_\n",
+        "print(\"Best hyperparameters:\", random_search.best_params_)\n",
+        "print(\"Best cross-validation F1-score:\", random_search.best_score_)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KJCINYHCLL_O",
+        "outputId": "d03379d8-2c2a-4db6-997f-73ad2dd86616"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "📏 Calibrating probabilities...\n",
+            "\n",
+            "📈 Model Evaluation on Test Set:\n",
+            "F1 Score (Macro): 0.9141359042280297\n",
+            "Accuracy: 0.929\n",
+            "\n",
+            "Classification Report:\n",
+            "               precision    recall  f1-score   support\n",
+            "\n",
+            "        High       0.83      0.92      0.87       231\n",
+            "         Low       0.92      0.95      0.93       566\n",
+            "      Medium       0.96      0.92      0.94      1203\n",
+            "\n",
+            "    accuracy                           0.93      2000\n",
+            "   macro avg       0.90      0.93      0.91      2000\n",
+            "weighted avg       0.93      0.93      0.93      2000\n",
+            "\n",
+            "Cross-Validation F1 Scores: [0.94929183 0.94712258 0.94513455 0.94776378 0.95005877]\n",
+            "Mean CV F1 Score: 0.9479 ± 0.0017\n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 6. Calibrate Probabilities ----------------------\n",
+        "print(\"\\n📏 Calibrating probabilities...\")\n",
+        "\n",
+        "# Calibrate the best model using CalibratedClassifierCV with reduced folds\n",
+        "calibrated_rf = CalibratedClassifierCV(best_rf, method='sigmoid', cv=3, ensemble=True)\n",
+        "calibrated_rf.fit(X_train_res, y_train_res)\n",
+        "\n",
+        "# Evaluate calibrated model on test set\n",
+        "y_pred = calibrated_rf.predict(X_test)\n",
+        "y_proba = calibrated_rf.predict_proba(X_test)\n",
+        "\n",
+        "# Print evaluation metrics\n",
+        "print(\"\\n📈 Model Evaluation on Test Set:\")\n",
+        "print(\"F1 Score (Macro):\", f1_score(y_test, y_pred, average=\"macro\"))\n",
+        "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n",
+        "print(\"\\nClassification Report:\\n\", classification_report(y_test, y_pred, target_names=le.classes_))\n",
+        "\n",
+        "# Cross-validation on calibrated model\n",
+        "cv_scores = cross_val_score(calibrated_rf, X_train_res, y_train_res, cv=cv, scoring=\"f1_macro\")\n",
+        "print(f\"Cross-Validation F1 Scores: {cv_scores}\")\n",
+        "print(f\"Mean CV F1 Score: {cv_scores.mean():.4f} ± {cv_scores.std():.4f}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lB69j9OWLMJP",
+        "outputId": "66942bbc-dcaf-4441-97d5-5b2715f9c508"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "📉 Generating visualizations...\n",
+            "Visuals saved to model/ directory.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 7. Visual Insights ----------------------\n",
+        "print(\"\\n📉 Generating visualizations...\")\n",
+        "\n",
+        "# Ensure model directory exists\n",
+        "os.makedirs(\"model\", exist_ok=True)\n",
+        "\n",
+        "# Confusion Matrix\n",
+        "conf_matrix = confusion_matrix(y_test, y_pred)\n",
+        "plt.figure(figsize=(8, 6))\n",
+        "sns.heatmap(conf_matrix, annot=True, fmt=\"g\", cmap=\"Blues\", xticklabels=le.classes_, yticklabels=le.classes_)\n",
+        "plt.title(\"Confusion Matrix - RandomForest\")\n",
+        "plt.xlabel(\"Predicted\")\n",
+        "plt.ylabel(\"True\")\n",
+        "plt.savefig(\"model/rf_confusion_matrix.png\")\n",
+        "plt.close()\n",
+        "\n",
+        "# Feature Importance\n",
+        "feat_imp = pd.DataFrame({\"Feature\": features, \"Importance\": best_rf.feature_importances_})\n",
+        "feat_imp.sort_values(\"Importance\", ascending=False, inplace=True)\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "sns.barplot(x=\"Importance\", y=\"Feature\", data=feat_imp)\n",
+        "plt.title(\"Feature Importances - RandomForest\")\n",
+        "plt.tight_layout()\n",
+        "plt.savefig(\"model/rf_feature_importance.png\")\n",
+        "plt.close()\n",
+        "\n",
+        "print(\"Visuals saved to model/ directory.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KJCINYHCLL_O",
+        "outputId": "d03379d8-2c2a-4db6-997f-73ad2dd86616"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "💾 Saving model and encoder...\n",
+            "Model and encoder saved to model/ directory.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# ---------------------- 8. Save Model and Encoder ----------------------\n",
+        "print(\"\\n💾 Saving model and encoder...\")\n",
+        "\n",
+        "# Ensure model directory exists\n",
+        "os.makedirs(\"model\", exist_ok=True)\n",
+        "\n",
+        "# Save the calibrated model\n",
+        "joblib.dump(calibrated_rf, \"model/rf_injury_model.pkl\")\n",
+        "\n",
+        "# Save the label encoder\n",
+        "joblib.dump(le, \"model/rf_target_encoder.pkl\")\n",
+        "\n",
+        "print(\"Model and encoder saved to model/ directory.\")"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

deployment/model/XGBOOST.ipynb

@@ -0,0 +1,546 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# XGBoost Model for Injury Risk Prediction\n",
+        "\n",
+        "This notebook trains an XGBoost model to predict injury risk levels (Low, Medium, High) for athletes based on their training and physical attributes. The pipeline includes data loading, preprocessing, feature engineering, model training with hyperparameter tuning, probability calibration, and evaluation.\n",
+        "\n",
+        "## Objectives\n",
+        "- Load and preprocess the dataset consistently with the RandomForest model.\n",
+        "- Perform feature engineering to create meaningful features.\n",
+        "- Train an XGBoost model with hyperparameter tuning.\n",
+        "- Calibrate probabilities to ensure reliable confidence scores.\n",
+        "- Evaluate the model using appropriate metrics and visualizations.\n",
+        "- Save the model and encoder for use in the prediction pipeline."
+      ],
+      "metadata": {
+        "id": "X4Q8pyQ9mKOa"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "X4Q8pyQ9mKOa"
+      },
+      "outputs": [],
+      "source": [
+        "# Import libraries\n",
+        "import os\n",
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import xgboost as xgb\n",
+        "import joblib\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "from sklearn.model_selection import train_test_split, GridSearchCV\n",
+        "from sklearn.metrics import classification_report, confusion_matrix, f1_score, accuracy_score\n",
+        "from sklearn.preprocessing import LabelEncoder\n",
+        "from imblearn.over_sampling import SMOTE\n",
+        "from sklearn.calibration import CalibratedClassifierCV\n",
+        "\n",
+        "# Set seed for reproducibility\n",
+        "np.random.seed(42)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 1. Load Dataset ----------------------\n",
+        "# Load the dataset\n",
+        "df = pd.read_csv(\"/content/Refined_Sports_Injury_Dataset.csv\")\n",
+        "\n",
+        "# Display dataset info\n",
+        "print(\"Dataset loaded. Shape:\", df.shape)\n",
+        "print(\"\\nDataset Info:\")\n",
+        "print(df.info())\n",
+        "print(\"\\nClass Distribution:\")\n",
+        "print(df[\"Injury_Risk_Level\"].value_counts())"
+      ],
+      "metadata": {
+        "id": "AkHrpR7omsxv",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "e685149d-3638-4c1c-9261-be48b842afab"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Dataset loaded. Shape: (10000, 18)\n",
+            "\n",
+            "Dataset Info:\n",
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 10000 entries, 0 to 9999\n",
+            "Data columns (total 18 columns):\n",
+            " #   Column                        Non-Null Count  Dtype  \n",
+            "---  ------                        --------------  -----  \n",
+            " 0   Age                           10000 non-null  int64  \n",
+            " 1   Gender                        10000 non-null  object \n",
+            " 2   Sport_Type                    10000 non-null  object \n",
+            " 3   Experience_Level              10000 non-null  object \n",
+            " 4   Flexibility_Score             10000 non-null  float64\n",
+            " 5   Total_Weekly_Training_Hours   10000 non-null  float64\n",
+            " 6   High_Intensity_Training_Hours 10000 non-null  float64\n",
+            " 7   Strength_Training_Frequency   10000 non-null  int64  \n",
+            " 8   Recovery_Time_Between_Sessions 10000 non-null  float64\n",
+            " 9   Training_Load_Score           10000 non-null  float64\n",
+            " 10  Sprint_Speed                  10000 non-null  float64\n",
+            " 11  Endurance_Score               10000 non-null  float64\n",
+            " 12  Agility_Score                 10000 non-null  float64\n",
+            " 13  Fatigue_Level                 10000 non-null  int64  \n",
+            " 14  Previous_Injury_Count         10000 non-null  int64  \n",
+            " 15  Previous_Injury_Type          10000 non-null  object \n",
+            " 16  Injury_Risk_Level             10000 non-null  object \n",
+            " 17  Injury_Outcome                10000 non-null  int64  \n",
+            "dtypes: float64(8), int64(5), object(5)\n",
+            "memory usage: 1.4+ MB\n",
+            "None\n",
+            "\n",
+            "Class Distribution:\n",
+            "Injury_Risk_Level\n",
+            "Medium    6014\n",
+            "Low       2832\n",
+            "High      1154\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 2. Encode Categorical Columns ----------------------\n",
+        "print(\"\\n🔠 Encoding categorical columns...\")\n",
+        "\n",
+        "# Define mappings for categorical variables (consistent with RandomForest)\n",
+        "gender_mapping = {\"Male\": 0, \"Female\": 1}\n",
+        "experience_mapping = {\"Beginner\": 0, \"Intermediate\": 1, \"Advanced\": 2, \"Professional\": 3}\n",
+        "injury_type_mapping = {\"None\": 0, \"Sprain\": 1, \"Ligament Tear\": 2, \"Tendonitis\": 3, \"Strain\": 4, \"Fracture\": 5}\n",
+        "\n",
+        "# Encode Gender\n",
+        "df[\"Gender\"] = df[\"Gender\"].map(gender_mapping).fillna(0).astype(int)\n",
+        "\n",
+        "# Encode Sport_Type dynamically\n",
+        "df[\"Sport_Type\"] = df[\"Sport_Type\"].astype(\"category\").cat.codes\n",
+        "\n",
+        "# Encode Experience_Level\n",
+        "df[\"Experience_Level\"] = df[\"Experience_Level\"].map(experience_mapping).fillna(0).astype(int)\n",
+        "\n",
+        "# Encode Previous_Injury_Type\n",
+        "df[\"Previous_Injury_Type\"] = df[\"Previous_Injury_Type\"].map(injury_type_mapping).fillna(0).astype(int)\n",
+        "\n",
+        "# Encode Target\n",
+        "le = LabelEncoder()\n",
+        "df[\"Injury_Risk_Level\"] = le.fit_transform(df[\"Injury_Risk_Level\"].astype(str))\n",
+        "\n",
+        "# Verify encoding\n",
+        "print(\"Encoded class mapping:\", dict(zip(le.classes_, range(len(le.classes_)))))\n",
+        "print(\"Sample of encoded data:\\n\", df.head())"
+      ],
+      "metadata": {
+        "id": "B4MoE4YtKU0d",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "e685149d-3638-4c1c-9261-be48b842afab"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "🔠 Encoding categorical columns...\n",
+            "Encoded class mapping: {'High': 0, 'Low': 1, 'Medium': 2}\n",
+            "Sample of encoded data:\n",
+            "    Age  Gender  Sport_Type  Experience_Level  Flexibility_Score  \\\n",
+            "0   34       0           2                 0                7.2   \n",
+            "1   29       1           4                 3                8.5   \n",
+            "2   31       0           2                 2                6.8   \n",
+            "3   27       1           0                 1                7.9   \n",
+            "4   33       0           3                 2                6.5   \n",
+            "\n",
+            "   Total_Weekly_Training_Hours  High_Intensity_Training_Hours  \\\n",
+            "0                         12.0                            4.0   \n",
+            "1                          8.0                            2.0   \n",
+            "2                         15.0                            6.0   \n",
+            "3                         10.0                            3.0   \n",
+            "4                          9.0                            3.0   \n",
+            "\n",
+            "   Strength_Training_Frequency  Recovery_Time_Between_Sessions  \\\n",
+            "0                            3                            48.0   \n",
+            "1                            2                            72.0   \n",
+            "2                            4                            36.0   \n",
+            "3                            2                            60.0   \n",
+            "4                            3                            48.0   \n",
+            "\n",
+            "   Training_Load_Score  Sprint_Speed  Endurance_Score  Agility_Score  \\\n",
+            "0                 65.0           6.8              7.5            7.0   \n",
+            "1                 45.0           7.2              8.0            8.2   \n",
+            "2                 80.0           6.5              7.0            6.8   \n",
+            "3                 55.0           7.0              7.8            7.5   \n",
+            "4                 60.0           6.7              7.2            6.9   \n",
+            "\n",
+            "   Fatigue_Level  Previous_Injury_Count  Previous_Injury_Type  \\\n",
+            "0              4                      1                     1   \n",
+            "1              2                      0                     0   \n",
+            "2              6                      2                     2   \n",
+            "3              3                      0                     0   \n",
+            "4              5                      1                     3   \n",
+            "\n",
+            "   Injury_Risk_Level  Injury_Outcome  \n",
+            "0                  2               0  \n",
+            "1                  1               0  \n",
+            "2                  0               1  \n",
+            "3                  1               0  \n",
+            "4                  2               0  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 3. Feature Engineering ----------------------\n",
+        "print(\"\\n🛠️ Creating derived features...\")\n",
+        "\n",
+        "# Replace 0 with 0.1 in Total_Weekly_Training_Hours to avoid division by zero\n",
+        "df[\"Total_Weekly_Training_Hours\"] = df[\"Total_Weekly_Training_Hours\"].replace(0, 0.1)\n",
+        "\n",
+        "# Create derived features\n",
+        "df[\"Intensity_Ratio\"] = df[\"High_Intensity_Training_Hours\"] / df[\"Total_Weekly_Training_Hours\"]\n",
+        "df[\"Recovery_Per_Training\"] = df[\"Recovery_Time_Between_Sessions\"] / df[\"Total_Weekly_Training_Hours\"]\n",
+        "\n",
+        "# Define features (removed Predicted_Injury_Type)\n",
+        "features = [\n",
+        "    \"Age\", \"Gender\", \"Sport_Type\", \"Experience_Level\", \"Flexibility_Score\",\n",
+        "    \"Total_Weekly_Training_Hours\", \"High_Intensity_Training_Hours\", \"Strength_Training_Frequency\",\n",
+        "    \"Recovery_Time_Between_Sessions\", \"Training_Load_Score\", \"Sprint_Speed\", \"Endurance_Score\",\n",
+        "    \"Agility_Score\", \"Fatigue_Level\", \"Previous_Injury_Count\", \"Previous_Injury_Type\",\n",
+        "    \"Intensity_Ratio\", \"Recovery_Per_Training\"\n",
+        "]\n",
+        "\n",
+        "# Prepare features and target\n",
+        "X = df[features]\n",
+        "y = df[\"Injury_Risk_Level\"]\n",
+        "\n",
+        "# Verify features\n",
+        "print(\"Features created:\", features)\n",
+        "print(\"Sample of features:\\n\", X.head())"
+      ],
+      "metadata": {
+        "id": "M4xvzYqzKU-9",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "e685149d-3638-4c1c-9261-be48b842afab"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "🛠️ Creating derived features...\n",
+            "Features created: ['Age', 'Gender', 'Sport_Type', 'Experience_Level', 'Flexibility_Score', 'Total_Weekly_Training_Hours', 'High_Intensity_Training_Hours', 'Strength_Training_Frequency', 'Recovery_Time_Between_Sessions', 'Training_Load_Score', 'Sprint_Speed', 'Endurance_Score', 'Agility_Score', 'Fatigue_Level', 'Previous_Injury_Count', 'Previous_Injury_Type', 'Intensity_Ratio', 'Recovery_Per_Training']\n",
+            "Sample of features:\n",
+            "    Age  Gender  Sport_Type  Experience_Level  Flexibility_Score  \\\n",
+            "0   34       0           2                 0                7.2   \n",
+            "1   29       1           4                 3                8.5   \n",
+            "2   31       0           2                 2                6.8   \n",
+            "3   27       1           0                 1                7.9   \n",
+            "4   33       0           3                 2                6.5   \n",
+            "\n",
+            "   Total_Weekly_Training_Hours  High_Intensity_Training_Hours  \\\n",
+            "0                         12.0                            4.0   \n",
+            "1                          8.0                            2.0   \n",
+            "2                         15.0                            6.0   \n",
+            "3                         10.0                            3.0   \n",
+            "4                          9.0                            3.0   \n",
+            "\n",
+            "   Strength_Training_Frequency  Recovery_Time_Between_Sessions  \\\n",
+            "0                            3                            48.0   \n",
+            "1                            2                            72.0   \n",
+            "2                            4                            36.0   \n",
+            "3                            2                            60.0   \n",
+            "4                            3                            48.0   \n",
+            "\n",
+            "   Training_Load_Score  Sprint_Speed  Endurance_Score  Agility_Score  \\\n",
+            "0                 65.0           6.8              7.5            7.0   \n",
+            "1                 45.0           7.2              8.0            8.2   \n",
+            "2                 80.0           6.5              7.0            6.8   \n",
+            "3                 55.0           7.0              7.8            7.5   \n",
+            "4                 60.0           6.7              7.2            6.9   \n",
+            "\n",
+            "   Fatigue_Level  Previous_Injury_Count  Previous_Injury_Type  Intensity_Ratio  \\\n",
+            "0              4                      1                     1        0.333333   \n",
+            "1              2                      0                     0        0.250000   \n",
+            "2              6                      2                     2        0.400000   \n",
+            "3              3                      0                     0        0.300000   \n",
+            "4              5                      1                     3        0.333333   \n",
+            "\n",
+            "   Recovery_Per_Training  \n",
+            "0                    4.0  \n",
+            "1                    9.0  \n",
+            "2                    2.4  \n",
+            "3                    6.0  \n",
+            "4                    5.3  \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 4. Train/Test Split & SMOTE ----------------------\n",
+        "print(\"\\n📊 Splitting data & applying SMOTE...\")\n",
+        "\n",
+        "# Split data into train and test sets\n",
+        "X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.2, random_state=42)\n",
+        "\n",
+        "# Apply SMOTE to balance the training set\n",
+        "X_train_res, y_train_res = SMOTE(random_state=42).fit_resample(X_train, y_train)\n",
+        "\n",
+        "# Print class distribution after SMOTE\n",
+        "print(\"Training set class distribution after SMOTE:\")\n",
+        "print(pd.Series(y_train_res).value_counts())"
+      ],
+      "metadata": {
+        "id": "GtyXbFTsKVUS",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "e685149d-3638-4c1c-9261-be48b842afab"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "📊 Splitting data & applying SMOTE...\n",
+            "Training set class distribution after SMOTE:\n",
+            "0    4811\n",
+            "1    4811\n",
+            "2    4811\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 5. Hyperparameter Tuning with GridSearchCV ----------------------\n",
+        "print(\"\\n🔍 Performing hyperparameter tuning...\")\n",
+        "\n",
+        "# Define XGBoost model\n",
+        "xgb_model = xgb.XGBClassifier(\n",
+        "    objective=\"multi:softprob\",\n",
+        "    eval_metric=\"mlogloss\",\n",
+        "    num_class=len(le.classes_),\n",
+        "    random_state=42\n",
+        ")\n",
+        "\n",
+        "# Define hyperparameter grid\n",
+        "param_grid = {\n",
+        "    'n_estimators': [100, 200, 300],\n",
+        "    'max_depth': [5, 10, 15],\n",
+        "    'learning_rate': [0.01, 0.1, 0.3],\n",
+        "    'subsample': [0.8, 1.0]\n",
+        "}\n",
+        "\n",
+        "# Perform grid search with cross-validation\n",
+        "grid_search = GridSearchCV(estimator=xgb_model, param_grid=param_grid, cv=5, scoring='f1_macro', n_jobs=-1)\n",
+        "grid_search.fit(X_train_res, y_train_res)\n",
+        "\n",
+        "# Get best model\n",
+        "best_xgb = grid_search.best_estimator_\n",
+        "print(\"Best hyperparameters:\", grid_search.best_params_)\n",
+        "print(\"Best cross-validation F1-score:\", grid_search.best_score_)"
+      ],
+      "metadata": {
+        "id": "CFoUgTwZKVf3",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "aae9b818-ef59-48e9-bb06-e079913edaf5"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "🔍 Performing hyperparameter tuning...\n",
+            "Best hyperparameters: {'learning_rate': 0.1, 'max_depth': 15, 'n_estimators': 300, 'subsample': 1.0}\n",
+            "Best cross-validation F1-score: 0.9561784041412857\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 6. Calibrate Probabilities ----------------------\n",
+        "print(\"\\n📏 Calibrating probabilities...\")\n",
+        "\n",
+        "# Calibrate the best model using CalibratedClassifierCV\n",
+        "calibrated_xgb = CalibratedClassifierCV(best_xgb, method='sigmoid', cv=5)\n",
+        "calibrated_xgb.fit(X_train_res, y_train_res)\n",
+        "\n",
+        "# Evaluate calibrated model on test set\n",
+        "y_pred = calibrated_xgb.predict(X_test)\n",
+        "y_proba = calibrated_xgb.predict_proba(X_test)\n",
+        "\n",
+        "# Print evaluation metrics\n",
+        "print(\"\\n📈 Model Evaluation on Test Set:\")\n",
+        "print(\"F1 Score (Macro):\", f1_score(y_test, y_pred, average=\"macro\"))\n",
+        "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n",
+        "print(\"\\nClassification Report:\\n\", classification_report(y_test, y_pred, target_names=le.classes_))"
+      ],
+      "metadata": {
+        "id": "5Fgs6oHUKVwK",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c2f9145f-8f25-40ef-b1d9-26d85332cc2f"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "📏 Calibrating probabilities...\n",
+            "\n",
+            "📈 Model Evaluation on Test Set:\n",
+            "F1 Score (Macro): 0.9154651493598866\n",
+            "Accuracy: 0.929\n",
+            "\n",
+            "Classification Report:\n",
+            "               precision    recall  f1-score   support\n",
+            "\n",
+            "        High       0.82      0.90      0.86       231\n",
+            "         Low       0.93      0.94      0.94       566\n",
+            "      Medium       0.95      0.93      0.94      1203\n",
+            "\n",
+            "    accuracy                           0.93      2000\n",
+            "   macro avg       0.90      0.93      0.92      2000\n",
+            "weighted avg       0.93      0.93      0.93      2000\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 7. Visual Insights ----------------------\n",
+        "print(\"\\n📉 Generating visualizations...\")\n",
+        "\n",
+        "# Confusion Matrix\n",
+        "conf_matrix = confusion_matrix(y_test, y_pred)\n",
+        "plt.figure(figsize=(8, 6))\n",
+        "sns.heatmap(conf_matrix, annot=True, fmt=\"g\", cmap=\"Blues\", xticklabels=le.classes_, yticklabels=le.classes_)\n",
+        "plt.title(\"Confusion Matrix - XGBoost\")\n",
+        "plt.xlabel(\"Predicted\")\n",
+        "plt.ylabel(\"True\")\n",
+        "plt.savefig(\"model/xgb_confusion_matrix.png\")\n",
+        "plt.close()\n",
+        "\n",
+        "# Feature Importance\n",
+        "feat_imp = pd.DataFrame({\"Feature\": features, \"Importance\": best_xgb.feature_importances_})\n",
+        "feat_imp.sort_values(\"Importance\", ascending=False, inplace=True)\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "sns.barplot(x=\"Importance\", y=\"Feature\", data=feat_imp)\n",
+        "plt.title(\"Feature Importances - XGBoost\")\n",
+        "plt.tight_layout()\n",
+        "plt.savefig(\"model/xgb_feature_importance.png\")\n",
+        "plt.close()\n",
+        "\n",
+        "print(\"Visuals saved to model/ directory.\")"
+      ],
+      "metadata": {
+        "id": "5Fgs6oHUKVwK",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c2f9145f-8f25-40ef-b1d9-26d85332cc2f"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "📉 Generating visualizations...\n",
+            "Visuals saved to model/ directory.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ---------------------- 8. Save Model and Encoder ----------------------\n",
+        "print(\"\\n💾 Saving model and encoder...\")\n",
+        "\n",
+        "# Create model directory if it doesn't exist\n",
+        "os.makedirs(\"model\", exist_ok=True)\n",
+        "\n",
+        "# Save the calibrated model\n",
+        "joblib.dump(calibrated_xgb, \"model/xgboost_injury_model.pkl\")\n",
+        "\n",
+        "# Save the label encoder\n",
+        "joblib.dump(le, \"model/xgb_target_encoder.pkl\")\n",
+        "\n",
+        "print(\"Model and encoder saved to model/ directory.\")"
+      ],
+      "metadata": {
+        "id": "4bvmzxoJKlI1",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "5753ab2c-7494-48f8-98df-ad70c45377b7"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "💾 Saving model and encoder...\n",
+            "Model and encoder saved to model/ directory.\n"
+          ]
+        }
+      ]
+    }
+  ]
+}