Upload 10 files

deployment/api/app.py

@@ -0,0 +1,141 @@
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+from predict import predict_injury_risk
+from recommendation import generate_recommendations
+import os
+import requests
+import json
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Define paths
+FRONTEND_FOLDER = os.path.join(os.path.dirname(__file__), "..", "..", "UI2")  # Point to UI2 in the root directory
+
+app = Flask(__name__, static_folder=FRONTEND_FOLDER, template_folder=FRONTEND_FOLDER, static_url_path="")
+CORS(app)
+
+# Cohere API setup
+COHERE_API_TOKEN = os.getenv("COHERE_API_TOKEN")
+if not COHERE_API_TOKEN:
+    raise ValueError("COHERE_API_TOKEN environment variable is not set")
+COHERE_API_URL = "https://api.cohere.ai/v1/generate"
+
+# System prompt for context
+SYSTEM_PROMPT = (
+    "You are AthleteGuard AI, an assistant for a sports injury prediction system. "
+    "Answer questions about sports injuries, prevention, and the system concisely (under 100 words). "
+    "Context: Sports injuries result from overuse, improper technique, or insufficient recovery. "
+    "Shin splints are caused by repetitive stress, often from running or improper footwear. "
+    "Prevent injuries with balanced training, proper gear, and fatigue monitoring. "
+    "The system uses RandomForest and XGBoost to predict injury risk with 92% accuracy. "
+    "For personal injury risk queries, prompt the user to provide data via the calculator form."
+)
+
+# Serve index.html
+@app.route("/", methods=["GET"])
+def serve_index():
+    return send_from_directory(FRONTEND_FOLDER, "index.html")
+
+# Serve calculator.html
+@app.route("/calculator.html", methods=["GET"])
+def serve_calculator():
+    return send_from_directory(FRONTEND_FOLDER, "calculator.html")
+
+# Serve about.html
+@app.route("/about.html", methods=["GET"])
+def serve_about():
+    return send_from_directory(FRONTEND_FOLDER, "about.html")
+
+# Serve chatbot.html
+@app.route("/chatbot.html", methods=["GET"])
+def serve_chatbot():
+    return send_from_directory(FRONTEND_FOLDER, "chatbot.html")
+
+# Serve static files (JS, CSS)
+@app.route("/<path:filename>")
+def serve_static_files(filename):
+    return send_from_directory(FRONTEND_FOLDER, filename)
+
+# API: Injury prediction
+@app.route("/predict", methods=["POST"])
+def predict():
+    try:
+        input_data = request.get_json()
+        result = predict_injury_risk(input_data)
+        return jsonify(result)
+    except Exception as e:
+        logger.error(f"Predict endpoint error: {str(e)}")
+        return jsonify({"error": str(e)}), 400
+
+# API: Chatbot
+@app.route("/chat", methods=["POST"])
+def chat():
+    try:
+        data = request.get_json()
+        logger.debug(f"Received chat request: {data}")
+        user_input = data.get("message", "").lower()
+        user_data = data.get("user_data", None)
+
+        if "risk" in user_input or "predict" in user_input or "my" in user_input:
+            if user_data:
+                result = predict_injury_risk(user_data)
+                response = (
+                    f"Your injury risk is {result['predicted_risk_level']} "
+                    f"({result['injury_likelihood_percent']}%). "
+                    f"Recommendations: {', '.join(result['recommendations'])}"
+                )
+            else:
+                response = "Please provide details like age, training hours, and fatigue level using the calculator form."
+            return jsonify({"response": response, "requires_data": not user_data})
+
+        headers = {
+            "Authorization": f"Bearer {COHERE_API_TOKEN}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "model": "command",
+            "prompt": f"{SYSTEM_PROMPT}\nUser: {user_input}\nAssistant:",
+            "max_tokens": 100,
+            "temperature": 0.7
+        }
+        logger.debug(f"Sending Cohere API request: {payload}")
+        response = requests.post(COHERE_API_URL, headers=headers, json=payload)
+        logger.debug(f"Cohere API response status: {response.status_code}, content: {response.text}")
+
+        if response.status_code != 200:
+            logger.error(f"Cohere API error: {response.status_code} - {response.text}")
+            return jsonify({"error": f"Cohere API error: {response.status_code} - {response.text}"}), 500
+
+        try:
+            answer = response.json()["generations"][0]["text"].strip()
+        except (KeyError, IndexError, TypeError) as e:
+            logger.error(f"Unexpected API response format: {str(response.json())}")
+            return jsonify({"error": f"Unexpected API response format: {str(response.json())}"}), 500
+
+        if "prevent" in user_input or "avoid" in user_input:
+            sample_input = {
+                "Fatigue_Level": 5,
+                "Recovery_Time_Between_Sessions": 12,
+                "Total_Weekly_Training_Hours": 10,
+                "High_Intensity_Training_Hours": 3,
+                "Previous_Injury_Count": 0,
+                "Flexibility_Score": 5,
+                "Agility_Score": 5,
+                "Strength_Training_Frequency": 2,
+                "Experience_Level": 1,
+                "Sport_Type": 0
+            }
+            recs = generate_recommendations(sample_input)
+            answer += " Specific tips: " + ", ".join(recs)
+
+        logger.debug(f"Chat response: {answer}")
+        return jsonify({"response": answer, "requires_data": False})
+    except Exception as e:
+        logger.error(f"Chat endpoint error: {str(e)}")
+        return jsonify({"error": str(e)}), 400
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)

deployment/api/predict.py

@@ -0,0 +1,127 @@
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from recommendation import generate_recommendations
+
+# Define mappings for categorical variables (consistent with CalibrateLikelihood.ipynb)
+gender_mapping = {"Male": 0, "Female": 1}
+experience_mapping = {"Beginner": 0, "Intermediate": 1, "Advanced": 2, "Professional": 3}
+injury_type_mapping = {"None": 0, "Sprain": 1, "Ligament Tear": 2, "Tendonitis": 3, "Strain": 4, "Fracture": 5}
+sport_type_mapping = {"Football": 0, "Basketball": 1, "Swimming": 2, "Tennis": 3, "Running": 4}
+risk_level_mapping = {0: "High", 1: "Low", 2: "Medium"}
+
+# Define model directory using relative path
+MODEL_DIR = os.path.join(os.path.dirname(__file__), "..", "model")
+
+# Load models, encoders, and calibration threshold
+try:
+    rf_model = joblib.load(os.path.join(MODEL_DIR, "rf_injury_model.pkl"))
+    xgb_model = joblib.load(os.path.join(MODEL_DIR, "xgboost_injury_model.pkl"))
+    calibrator = joblib.load(os.path.join(MODEL_DIR, "likelihood_calibrator.pkl"))
+    rf_encoder = joblib.load(os.path.join(MODEL_DIR, "rf_target_encoder.pkl"))
+    xgb_encoder = joblib.load(os.path.join(MODEL_DIR, "xgb_target_encoder.pkl"))
+    low_threshold = joblib.load(os.path.join(MODEL_DIR, "calibration_threshold.pkl"))
+except FileNotFoundError as e:
+    raise FileNotFoundError(f"Model file not found: {str(e)}. Ensure all model files are in {MODEL_DIR}.")
+
+# Verify encoder consistency
+if not (rf_encoder.classes_ == xgb_encoder.classes_).all():
+    raise ValueError("RandomForest and XGBoost encoders have inconsistent class mappings.")
+
+def preprocess_data(data_dict):
+    """
+    Preprocess the input data consistently with CalibrateLikelihood.ipynb.
+    
+    Args:
+        data_dict (dict): Input dictionary containing athlete data.
+    
+    Returns:
+        pd.DataFrame: Preprocessed features ready for prediction.
+    """
+    try:
+        df = pd.DataFrame([data_dict])
+
+        df["Gender"] = df["Gender"].map(gender_mapping).fillna(0).astype(int)
+        df["Sport_Type"] = df["Sport_Type"].map(sport_type_mapping).fillna(0).astype(int)
+        df["Experience_Level"] = df["Experience_Level"].map(experience_mapping).fillna(0).astype(int)
+        df["Previous_Injury_Type"] = df["Previous_Injury_Type"].fillna("None")
+        df["Previous_Injury_Type"] = df["Previous_Injury_Type"].map(injury_type_mapping).fillna(0).astype(int)
+
+        df["Total_Weekly_Training_Hours"] = df["Total_Weekly_Training_Hours"].replace(0, 0.1)
+
+        df["Intensity_Ratio"] = df["High_Intensity_Training_Hours"] / df["Total_Weekly_Training_Hours"]
+        df["Recovery_Per_Training"] = df["Recovery_Time_Between_Sessions"] / df["Total_Weekly_Training_Hours"]
+
+        features = [
+            "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"
+        ]
+
+        missing_features = [f for f in features if f not in df.columns]
+        if missing_features:
+            raise ValueError(f"Missing required features: {missing_features}")
+
+        X = df[features]
+        return X
+    except Exception as e:
+        raise Exception(f"Error in preprocessing data: {str(e)}")
+
+def predict_injury_risk(user_input: dict) -> dict:
+    """
+    Predict injury risk using the ensemble of RandomForest and XGBoost models with calibrated probabilities.
+    Uses a data-driven threshold from calibration to classify Low vs. Medium risks.
+    
+    Args:
+        user_input (dict): Input dictionary containing athlete data.
+    
+    Returns:
+        dict: Prediction results including risk level, likelihood, and recommendations.
+    """
+    print("User Input Received:\n", user_input)
+
+    # Preprocess input
+    features = preprocess_data(user_input)
+    print("FINAL Features After Preprocessing:", list(features.columns))
+    print("Preprocessed Input:\n", features)
+
+    # Predict probabilities from both models
+    rf_probs = rf_model.predict_proba(features)
+    xgb_probs = xgb_model.predict_proba(features)
+    print("RandomForest Probabilities (High, Low, Medium):", rf_probs)
+    print("XGBoost Probabilities (High, Low, Medium):", xgb_probs)
+
+    # Ensemble average
+    avg_probs = (rf_probs + xgb_probs) / 2
+    predicted_class = np.argmax(avg_probs, axis=1)[0]
+    confidence = np.max(avg_probs, axis=1)[0]
+    predicted_label = rf_encoder.inverse_transform([predicted_class])[0]
+    print("Ensemble Probabilities (High, Low, Medium):", avg_probs)
+    print("Predicted Class:", predicted_class, "Label:", predicted_label, "Confidence:", confidence)
+
+    # Calibrate the probability using the likelihood calibrator
+    calib_data = pd.DataFrame({
+        "prob_high": [avg_probs[0][0]],
+        "prob_low": [avg_probs[0][1]],
+        "prob_medium": [avg_probs[0][2]]
+    })
+    injury_likelihood = calibrator.predict_proba(calib_data)[:, 1][0] * 100
+    print("Calibrated Injury Likelihood (%):", injury_likelihood)
+
+    # Adjust prediction using dynamic threshold based on raw prob_low
+    if avg_probs[0][1] > low_threshold and predicted_label != "Low":
+        print(f"⚠️ Calibration adjustment: Low probability ({avg_probs[0][1]:.2f}) above threshold ({low_threshold:.2f}) — classifying as Low.")
+        predicted_label = "Low"
+
+    # Generate recommendations
+    recommendations = generate_recommendations(user_input)
+
+    return {
+        "predicted_risk_level": predicted_label,
+        "injury_likelihood_percent": round(injury_likelihood, 2),
+        "model_class_probability": round(confidence * 100, 2),
+        "recommendations": recommendations
+    }

deployment/api/preprocessing.py

@@ -0,0 +1,48 @@
+import pandas as pd
+
+def preprocess_data(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Preprocess input data for injury risk prediction.
+    
+    Args:
+        df (pd.DataFrame): Input DataFrame with raw features.
+    
+    Returns:
+        pd.DataFrame: Processed DataFrame with engineered features.
+    """
+    # Input validation
+    required_columns = [
+        "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"
+    ]
+    
+    # Check for missing columns
+    missing_cols = [col for col in required_columns if col not in df.columns]
+    if missing_cols:
+        raise ValueError(f"Missing required columns: {missing_cols}")
+    
+    # Create a copy to avoid modifying the original DataFrame
+    df_processed = df.copy()
+    
+    # Handle missing values (fill with median)
+    df_processed.fillna(df_processed.median(), inplace=True)
+    
+    # Replace 0 with 0.1 in Total_Weekly_Training_Hours to avoid division by zero
+    df_processed["Total_Weekly_Training_Hours"] = df_processed["Total_Weekly_Training_Hours"].replace(0, 0.1)
+    
+    # Create derived features
+    df_processed["Intensity_Ratio"] = df_processed["High_Intensity_Training_Hours"] / df_processed["Total_Weekly_Training_Hours"]
+    df_processed["Recovery_Per_Training"] = df_processed["Recovery_Time_Between_Sessions"] / df_processed["Total_Weekly_Training_Hours"]
+    
+    # Define final feature set (excluding Predicted_Injury_Type)
+    model_features = [
+        "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"
+    ]
+    
+    return df_processed[model_features]

deployment/api/recommendation.py

@@ -0,0 +1,202 @@
+# Professional Injury Prevention Recommendation System
+"""
+Generates evidence-based, personalized injury prevention recommendations for athletes.
+Aligned with the injury prediction model and integrated with the frontend.
+Recommendations include actionable advice, priorities, detailed explanations, and credible sources.
+"""
+
+from typing import List, Dict, Any
+import uuid
+
+def generate_recommendations(user_input: Dict[str, Any]) -> List[str]:
+    """
+    Generate professional, targeted injury prevention strategies.
+
+    Args:
+        user_input: Dictionary with fields like Age, Gender, Fatigue_Level, etc.
+
+    Returns:
+        List of recommendation strings (simplified for compatibility with existing frontend).
+    """
+    # Internal structure for recommendations with categories
+    internal_recs = {
+        "Recovery Strategies": [],
+        "Training Adjustments": [],
+        "Injury Prevention": [],
+        "Nutrition": [],
+        "Mental Health": [],
+        "Sport-Specific Warm-Ups": []
+    }
+
+    # Helper function to calculate priority
+    def calculate_priority(factor_value: float, threshold: float, weight: float) -> float:
+        return min(1.0, max(0.0, (factor_value / threshold) * weight))
+
+    # Fatigue Management
+    fatigue = user_input.get("Fatigue_Level", 5)
+    if fatigue >= 8:
+        internal_recs["Recovery Strategies"].append({
+            "id": str(uuid.uuid4()),
+            "text": "High fatigue detected. Prioritize 48–72 hours of active recovery with hydration and 8+ hours of sleep nightly.",
+            "priority": calculate_priority(fatigue, 10, 0.9),
+            "details": "Incorporate light stretching and 2–3L of water daily. Monitor sleep quality with a tracker for optimal recovery.",
+            "source": "https://www.mayoclinic.org/healthy-lifestyle/fitness/in-depth/recovery/art-20057777",
+            "category": "Recovery Strategies"
+        })
+    elif fatigue >= 6:
+        internal_recs["Recovery Strategies"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Elevated fatigue: Reduce high-intensity sessions by 20% this week and monitor soreness.",
+            "priority": calculate_priority(fatigue, 10, 0.7),
+            "details": "Use foam rolling for 10–15 minutes post-session to alleviate muscle tension and promote circulation.",
+            "source": "https://www.nsca.com/education/articles/recovery-techniques-for-athletes/",
+            "category": "Recovery Strategies"
+        })
+
+    # Recovery Time Optimization
+    recovery = user_input.get("Recovery_Time_Between_Sessions", 12)
+    if recovery < 8:
+        internal_recs["Recovery Strategies"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Insufficient recovery time. Increase rest to 12–24 hours between sessions.",
+            "priority": calculate_priority(8 - recovery, 8, 0.8),
+            "details": "Schedule sessions to allow muscle repair, especially after high-intensity workouts, to reduce injury risk.",
+            "source": "https://pubmed.ncbi.nlm.nih.gov/28933711/",
+            "category": "Recovery Strategies"
+        })
+
+    # Intensity Ratio Check
+    total_hours = max(user_input.get("Total_Weekly_Training_Hours", 1), 1)
+    hi_hours = user_input.get("High_Intensity_Training_Hours", 0)
+    intensity_ratio = hi_hours / total_hours
+    if intensity_ratio > 0.7:
+        internal_recs["Training Adjustments"].append({
+            "id": str(uuid.uuid4()),
+            "text": "High-intensity training exceeds 70%. Shift to 60% low-intensity/technical work.",
+            "priority": calculate_priority(intensity_ratio, 1, 0.75),
+            "details": "Incorporate drills focusing on technique or endurance to balance training load and prevent overtraining.",
+            "source": "https://www.acsm.org/docs/default-source/files-for-resource-library/overtraining.pdf",
+            "category": "Training Adjustments"
+        })
+
+    # Previous Injury Consideration
+    injury_count = user_input.get("Previous_Injury_Count", 0)
+    if injury_count >= 2:
+        internal_recs["Injury Prevention"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Multiple injuries noted. Add daily mobility and strength balance exercises.",
+            "priority": calculate_priority(injury_count, 5, 0.85),
+            "details": "Perform exercises like single-leg squats and hip bridges for 15 minutes daily to enhance joint stability.",
+            "source": "https://www.physio-pedia.com/Injury_Prevention_in_Sports",
+            "category": "Injury Prevention"
+        })
+
+    # Flexibility and Agility
+    flexibility = user_input.get("Flexibility_Score", 5)
+    if flexibility < 5:
+        internal_recs["Injury Prevention"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Low flexibility. Include 10–15 minutes of dynamic warm-ups and static stretching daily.",
+            "priority": calculate_priority(5 - flexibility, 5, 0.65),
+            "details": "Focus on hamstrings, hip flexors, and shoulders with stretches like lunges and arm circles to improve range of motion.",
+            "source": "https://www.mayoclinic.org/healthy-lifestyle/fitness/in-depth/stretching/art-20047931",
+            "category": "Injury Prevention"
+        })
+
+    agility = user_input.get("Agility_Score", 5)
+    if agility < 5:
+        internal_recs["Training Adjustments"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Improve agility with cone drills and ladder exercises twice weekly.",
+            "priority": calculate_priority(5 - agility, 5, 0.6),
+            "details": "Perform 3 sets of 10 reps for drills like lateral shuffles or T-drills to enhance quickness and coordination.",
+            "source": "https://www.nsca.com/education/articles/agility-and-quickness-training/",
+            "category": "Training Adjustments"
+        })
+
+    # Strength Training Frequency
+    strength_freq = user_input.get("Strength_Training_Frequency", 0)
+    if strength_freq < 2:
+        internal_recs["Training Adjustments"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Increase strength training to 2–3 sessions/week for joint stability.",
+            "priority": calculate_priority(2 - strength_freq, 2, 0.7),
+            "details": "Include compound lifts like squats and deadlifts with moderate weights to build resilience.",
+            "source": "https://www.acsm.org/docs/default-source/files-for-resource-library/strength-training.pdf",
+            "category": "Training Adjustments"
+        })
+
+    # Nutrition for Recovery
+    if fatigue >= 6 or recovery < 12:
+        internal_recs["Nutrition"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Optimize nutrition with 1.2–2.0g/kg body weight protein daily for recovery.",
+            "priority": calculate_priority(max(fatigue, 12 - recovery), 10, 0.6),
+            "details": "Consume protein-rich meals within 2 hours post-workout (e.g., chicken, eggs, or whey) to support muscle repair.",
+            "source": "https://jissn.biomedcentral.com/articles/10.1186/s12970-017-0177-8",
+            "category": "Nutrition"
+        })
+
+    # Mental Health
+    if fatigue >= 7:
+        internal_recs["Mental Health"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Address mental fatigue with 10–15 minutes of mindfulness or meditation daily.",
+            "priority": calculate_priority(fatigue, 10, 0.55),
+            "details": "Use guided meditation apps or breathing exercises to reduce stress and improve focus.",
+            "source": "https://www.mayoclinic.org/tests-procedures/meditation/in-depth/meditation/art-20045858",
+            "category": "Mental Health"
+        })
+
+    # Sport-Specific Warm-Ups
+    sport_type = user_input.get("Sport_Type", 0)
+    if sport_type == 0:  # Football
+        internal_recs["Sport-Specific Warm-Ups"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Football: Perform dynamic warm-ups with high-knee sprints and lateral cuts for 10 minutes.",
+            "priority": 0.6,
+            "details": "Focus on explosive movements to prepare for sprinting and tackling demands.",
+            "source": "https://www.nsca.com/education/articles/warm-ups-for-soccer/",
+            "category": "Sport-Specific Warm-Ups"
+        })
+    elif sport_type == 3:  # Running
+        internal_recs["Sport-Specific Warm-Ups"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Running: Include 10-minute warm-ups with leg swings and walking lunges.",
+            "priority": 0.6,
+            "details": "Emphasize hip mobility and gradual pace increases to prevent shin splints and strains.",
+            "source": "https://www.runnersworld.com/training/a20787998/dynamic-warmup/",
+            "category": "Sport-Specific Warm-Ups"
+        })
+
+    # Age-Based Recommendations
+    age = user_input.get("Age", 30)
+    if age > 40:
+        internal_recs["Injury Prevention"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Age over 40: Add low-impact cross-training (e.g., swimming, yoga) twice weekly.",
+            "priority": calculate_priority(age - 40, 40, 0.6),
+            "details": "Low-impact activities reduce joint stress while maintaining fitness.",
+            "source": "https://www.arthritis.org/health-wellness/healthy-living/physical-activity/other-activities/low-impact-exercises",
+            "category": "Injury Prevention"
+        })
+
+    # Gender-Specific Recommendations
+    gender = user_input.get("Gender", 0)
+    if gender == 1:  # Female
+        internal_recs["Injury Prevention"].append({
+            "id": str(uuid.uuid4()),
+            "text": "Female athletes: Include pelvic floor exercises 3 times/week to support core stability.",
+            "priority": 0.65,
+            "details": "Exercises like Kegels strengthen the pelvic floor, reducing injury risk during high-impact activities.",
+            "source": "https://www.womenshealthmag.com/fitness/a20709126/pelvic-floor-exercises/",
+            "category": "Injury Prevention"
+        })
+
+    # Flatten recommendations for compatibility with existing frontend
+    flat_recommendations = []
+    for category in internal_recs:
+        for rec in internal_recs[category]:
+            flat_recommendations.append(rec["text"])
+
+    return flat_recommendations

deployment/model/calibration_threshold.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d4a700a3a9d9189b6dc34f3e5704d1851855f86c19d32db13ecda0dccbd1202
+size 117

deployment/model/likelihood_calibrator.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e669ee317df2373ba4b025d4f3d99c3b00258d488b9aa2612fd2db8e6586b210
+size 1247

deployment/model/rf_injury_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:128cd660a06279de530ae484e6878c0049bd33536e8398bb90632820645919cf
+size 80605269

deployment/model/rf_target_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82243ebe944079adcf57dd5ff06f2dfebd07a9c71d824f2a2cd214555b5e36cf
+size 553

deployment/model/xgb_target_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82243ebe944079adcf57dd5ff06f2dfebd07a9c71d824f2a2cd214555b5e36cf
+size 553

deployment/model/xgboost_injury_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d31c73649e76af5c98d0095b63a6e8b437758591fe88455c70342ff9f202121
+size 23315040