Upload 11 files

Dockerfile

@@ -1,29 +1,12 @@
-FROM python:3.10-slim
 
-WORKDIR /app
-
-# Install build dependencies
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create a non-root user
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
+FROM python:3.10
 
-# Copy requirements file first for better layer caching
-COPY --chown=user:user requirements.txt .
-
-# Install required packages from requirements.txt
-RUN pip install --no-cache-dir --user -r requirements.txt
+WORKDIR /app
 
-# Make sure python-multipart is installed - use quotes to prevent shell issues
-RUN pip install --no-cache-dir --user "python-multipart>=0.0.6"
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application files
-COPY --chown=user:user . .
+COPY model.joblib .
+COPY app.py .
 
-# Run the application
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"] 
+CMD ["python", "app.py"]

app.py

@@ -1,447 +1,241 @@
-try:
-    import multipart
-    print("python-multipart is installed: ", multipart.__version__)
-except ImportError:
-    print("python-multipart is NOT installed. Installing now...")
-    import subprocess
-    subprocess.check_call(["pip", "install", "python-multipart"])
-    print("python-multipart has been installed")
 
-from fastapi import FastAPI, Request, HTTPException, Form
-from fastapi.middleware.cors import CORSMiddleware
-import numpy as np
 import joblib
-import os
-from typing import Optional
-import json
 import pandas as pd
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.preprocessing import StandardScaler, OneHotEncoder
+import numpy as np
+from fastapi import FastAPI, Form, File, UploadFile, Request
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
 import time
-import traceback
-
-app = FastAPI()
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins
-    allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],  # Allows all headers
-)
-
-# Risk categories
-RISK_CATEGORIES = {
-    'Very Low Risk': 0.1,
-    'Low Risk': 0.2,
-    'Moderate Risk': 0.4,
-    'High Risk': 0.6,
-    'Very High Risk': 0.8
-}
-
-# Feature importance dictionary based on medical knowledge
-FEATURE_IMPORTANCE = {
-    'age': 0.20,
-    'hypertension': 0.15,
-    'heart_disease': 0.15,
-    'avg_glucose_level': 0.12,
-    'bmi': 0.10,
-    'smoking_status': 0.10,
-    'gender': 0.08,
-    'work_type': 0.05,
-    'Residence_type': 0.03,
-    'ever_married': 0.02
-}
+import json
+from typing import Optional, List, Union
+import uvicorn
 
-# Load the model with better error handling
+# Load the trained model
 print("Loading model...")
+model_path = "/app/model.joblib"
+import os
+print(f"Model path: {model_path}")
+print(f"Model file exists: {os.path.exists(model_path)}")
+print(f"Model file size: {os.path.getsize(model_path) / 1024:.2f} KB")
+
 try:
-    model_path = os.path.join(os.path.dirname(__file__), "model.joblib")
-    print(f"Model path: {model_path}")
-    
-    if not os.path.exists(model_path):
-        raise FileNotFoundError(f"Model file not found at: {model_path}")
-    
-    print(f"Model file exists. Size: {os.path.getsize(model_path) / 1024:.2f} KB")
-    
-    model_data = joblib.load(model_path)
+    model_info = joblib.load(model_path)
     print("Model loaded successfully!")
     
-    # Validate model data structure
-    if not isinstance(model_data, dict):
-        print(f"Warning: Model data is not a dictionary as expected. Type: {type(model_data)}")
-        model_loaded = False
-        rf_model = None
-        preprocessor = None
-        encoded_cols = []
-        numeric_cols = []
-    else:
-        rf_model = model_data.get('model')
-        encoded_cols = model_data.get('encoded_cols', [])
-        numeric_cols = model_data.get('numeric_cols', [])
-        preprocessor = model_data.get('preprocessor')
-        
-        print(f"Model details: Type: {type(rf_model)}")
-        print(f"Features: {len(numeric_cols)} numeric features, {len(encoded_cols)} encoded features")
-        
-        if rf_model is None:
-            print("Warning: Model is None")
-            model_loaded = False
-        else:
-            # Test if the model has the expected methods
-            if hasattr(rf_model, 'predict_proba'):
-                print("Model has predict_proba method: ✅")
-                model_loaded = True
-            else:
-                print("Warning: Model does not have predict_proba method")
-                model_loaded = False
-except Exception as e:
-    print(f"Error loading model: {str(e)}")
-    traceback_str = traceback.format_exc()
-    print(f"Traceback: {traceback_str}")
-    rf_model = None
-    preprocessor = None
-    encoded_cols = []
-    numeric_cols = []
-    model_loaded = False
-
-def get_risk_level(probability):
-    """Get risk level based on probability score"""
-    for category, threshold in RISK_CATEGORIES.items():
-        if probability < threshold:
-            return category
-    return "Very High Risk"
-
-def preprocess_without_pandas(data):
-    """Preprocess input data without using pandas"""
-    # Handle numeric features
-    numeric_features = []
-    for col in numeric_cols:
-        if col == 'age':
-            numeric_features.append(float(data.get('age', 0)))
-        elif col == 'avg_glucose_level':
-            numeric_features.append(float(data.get('avg_glucose_level', 0)))
-        elif col == 'bmi':
-            numeric_features.append(float(data.get('bmi', 0)))
-    
-    # Create input array for categorical processing
-    categorical_input = np.array([[
-        data.get('gender', 'Male'),
-        data.get('hypertension', 0),
-        data.get('heart_disease', 0),
-        data.get('ever_married', 'No'),
-        data.get('work_type', 'Private'),
-        data.get('Residence_type', 'Urban'),
-        data.get('smoking_status', 'never smoked')
-    ]], dtype=object)
+    # Access model components
+    pipeline = model_info['model']
+    model = pipeline.named_steps['classifier']
+    print(f"Model details: Type: {type(model)}")
     
-    # Apply preprocessing
-    if preprocessor is not None:
-        try:
-            encoded_features = preprocessor.transform(categorical_input)
-            # Combine numeric and encoded features
-            features = np.concatenate([numeric_features, encoded_features.flatten()])
-            return features.reshape(1, -1)
-        except Exception as e:
-            print(f"Error in preprocessing: {str(e)}")
-            
-    # Return none if preprocessing fails
-    return None
-
-def predict_with_model(features):
-    """Make prediction using the loaded model"""
-    try:
-        if rf_model is not None and features is not None:
-            start_time = time.time()
-            probabilities = rf_model.predict_proba(features)
-            end_time = time.time()
-            
-            stroke_probability = probabilities[0, 1]  # Class 1 probability (stroke)
-            risk_level = get_risk_level(stroke_probability)
-            execution_time_ms = (end_time - start_time) * 1000
-            
-            # Get feature importances for explaining prediction
-            # Note: This uses global feature importance rather than 
-            # instance-specific importance for simplicity
-            important_features = []
-            if hasattr(rf_model, 'feature_importances_'):
-                feature_names = numeric_cols + encoded_cols
-                importances = rf_model.feature_importances_
-                
-                # Get top 5 most important features
-                imp_indices = np.argsort(importances)[-5:][::-1]
-                for i in imp_indices:
-                    if i < len(feature_names):
-                        important_features.append({
-                            'feature': feature_names[i],
-                            'importance': float(importances[i])
-                        })
-            
-            return {
-                'probability': stroke_probability,
-                'risk_level': risk_level,
-                'prediction_success': True,
-                'execution_time_ms': execution_time_ms,
-                'important_features': important_features
-            }
-    except Exception as e:
-        print(f"Error in model prediction: {str(e)}")
+    # Get preprocessing info
+    numeric_cols = model_info['numeric_cols']
+    categorical_cols = model_info['encoded_cols']
+    print(f"Features: {len(numeric_cols)} numeric features, {len(categorical_cols)} encoded features")
     
-    return {
-        'probability': None,
-        'risk_level': None,
-        'prediction_success': False,
-        'execution_time_ms': 0,
-        'important_features': []
-    }
-
-def get_top_risk_factors(data):
-    """Get top risk factors based on data and medical knowledge"""
-    risk_factors = []
-    
-    # Calculate risk contribution for each field
-    # Age risk
-    if 'age' in data:
-        age = float(data.get('age', 0))
-        if age > 75:
-            risk_factors.append({'factor': 'Advanced Age (>75)', 'contribution': 0.20})
-        elif age > 65:
-            risk_factors.append({'factor': 'Elderly Age (>65)', 'contribution': 0.15})
-        elif age > 55:
-            risk_factors.append({'factor': 'Higher Age (>55)', 'contribution': 0.10})
-    
-    # Major health risk factors
-    if data.get('hypertension', 0) == 1:
-        risk_factors.append({'factor': 'Hypertension', 'contribution': 0.15})
-    
-    if data.get('heart_disease', 0) == 1:
-        risk_factors.append({'factor': 'Heart Disease', 'contribution': 0.15})
-    
-    # Blood glucose levels
-    if 'avg_glucose_level' in data:
-        glucose = float(data.get('avg_glucose_level', 0))
-        if glucose > 200:
-            risk_factors.append({'factor': 'Very High Blood Glucose (>200)', 'contribution': 0.12})
-        elif glucose > 140:
-            risk_factors.append({'factor': 'High Blood Glucose (>140)', 'contribution': 0.10})
-    
-    # BMI-related risk
-    if 'bmi' in data:
-        bmi = float(data.get('bmi', 0))
-        if bmi > 30:
-            risk_factors.append({'factor': 'Obesity (BMI > 30)', 'contribution': 0.10})
-        elif bmi > 25:
-            risk_factors.append({'factor': 'Overweight (BMI > 25)', 'contribution': 0.07})
-    
-    # Smoking status
-    if data.get('smoking_status', '') == 'smokes':
-        risk_factors.append({'factor': 'Current Smoker', 'contribution': 0.10})
-    elif data.get('smoking_status', '') == 'formerly smoked':
-        risk_factors.append({'factor': 'Former Smoker', 'contribution': 0.05})
-    
-    # Sort by contribution (highest first)
-    risk_factors.sort(key=lambda x: x['contribution'], reverse=True)
-    
-    return risk_factors
+    # Verify model has predict_proba
+    has_predict_proba = hasattr(model, 'predict_proba')
+    print(f"Model has predict_proba method: {'Yes' if has_predict_proba else 'No'}")
+except Exception as e:
+    print(f"Error loading model: {e}")
+    model_info = None
 
-def fallback_prediction(data):
-    """Fallback prediction when model fails - improved version"""
-    # Get top risk factors
-    risk_factors = get_top_risk_factors(data)
-    
-    # Calculate total risk score
-    total_risk_score = sum(rf['contribution'] for rf in risk_factors)
-    
-    # Apply sigmoid function to create probability curve
-    # This creates more reasonable probability distribution
-    if total_risk_score > 0:
-        probability = 1 / (1 + np.exp(-5 * (total_risk_score - 0.5)))
-    else:
-        probability = 0.05  # Baseline risk
-    
-    return probability, get_risk_level(probability), risk_factors
+# Initialize FastAPI
+app = FastAPI(title="Stroke Prediction Model API")
 
-@app.get("/")
-async def root():
-    """Root endpoint for documentation and health check"""
-    return {
-        "message": "Stroke Prediction API is running",
-        "model_loaded": model_loaded,
-        "usage": "Send a POST request to / with patient data",
-        "example": {
-            "gender": "Male",
-            "age": 67,
-            "hypertension": 1,
-            "heart_disease": 0,
-            "ever_married": "Yes",
-            "work_type": "Private",
-            "Residence_type": "Urban",
-            "avg_glucose_level": 228.69,
-            "bmi": 36.6,
-            "smoking_status": "formerly smoked"
-        },
-        "api_endpoints": {
-            "standard": "POST /",
-            "form_data": "POST /api/predict"
-        },
-        "model_version": "1.0",
-        "last_updated": "2023-11-15"
-    }
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-@app.post("/")
-async def predict(request: Request):
-    """Make stroke prediction based on input data"""
-    try:
-        start_time = time.time()
-        data = await request.json()
-        
-        # Try using the model first
-        if model_loaded:
-            # Preprocess the data
-            features = preprocess_without_pandas(data)
-            
-            # Make prediction
-            model_result = predict_with_model(features)
-            
-            if model_result['prediction_success']:
-                # Calculate top risk factors for explanation
-                risk_factors = get_top_risk_factors(data)
-                
-                end_time = time.time()
-                execution_time_ms = (end_time - start_time) * 1000
-                
-                return {
-                    "probability": float(model_result['probability']),
-                    "prediction": model_result['risk_level'],
-                    "stroke_prediction": int(model_result['probability'] > 0.5),
-                    "risk_factors": [rf['factor'] for rf in risk_factors],
-                    "important_features": model_result['important_features'],
-                    "execution_time_ms": execution_time_ms,
-                    "using_model": True,
-                    "model_version": "1.0"
-                }
-        
-        # Use fallback if model fails or isn't loaded
-        probability, risk_level, risk_factors = fallback_prediction(data)
-        end_time = time.time()
-        execution_time_ms = (end_time - start_time) * 1000
-        
-        return {
-            "probability": float(probability),
-            "prediction": risk_level,
-            "stroke_prediction": int(probability > 0.5),
-            "risk_factors": [rf['factor'] for rf in risk_factors],
-            "using_model": False,
-            "execution_time_ms": execution_time_ms,
-            "model_version": "fallback-1.0"
-        }
-        
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Invalid input: {str(e)}")
+# Check if python-multipart is installed
+try:
+    import multipart
+    print("python-multipart is installed: ", multipart.__version__)
+except ImportError:
+    print("python-multipart is NOT installed")
 
+# Define prediction endpoints
 @app.post("/api/predict")
-async def predict_from_form(
+async def predict_stroke(
     gender: Optional[str] = Form(None),
     age: Optional[float] = Form(None),
     hypertension: Optional[int] = Form(None),
     heart_disease: Optional[int] = Form(None),
-    heartDisease: Optional[int] = Form(None),  # Alternative field name from frontend
     ever_married: Optional[str] = Form(None),
-    everMarried: Optional[str] = Form(None),  # Alternative field name from frontend
     work_type: Optional[str] = Form(None),
-    workType: Optional[str] = Form(None),  # Alternative field name from frontend
     Residence_type: Optional[str] = Form(None),
-    residenceType: Optional[str] = Form(None),  # Alternative field name from frontend
     avg_glucose_level: Optional[float] = Form(None),
-    avgGlucoseLevel: Optional[float] = Form(None),  # Alternative field name from frontend
     bmi: Optional[float] = Form(None),
-    smoking_status: Optional[str] = Form(None),
-    smokingStatus: Optional[str] = Form(None),  # Alternative field name from frontend
-    formDataJson: Optional[str] = Form(None)
+    smoking_status: Optional[str] = Form(None)
 ):
-    """API endpoint that accepts form data or JSON string for prediction"""
+    start_time = time.time()
+    
+    # Log the received data
+    form_data = {
+        'gender': gender,
+        'age': age,
+        'hypertension': hypertension,
+        'heart_disease': heart_disease,
+        'ever_married': ever_married,
+        'work_type': work_type,
+        'Residence_type': Residence_type,
+        'avg_glucose_level': avg_glucose_level,
+        'bmi': bmi,
+        'smoking_status': smoking_status
+    }
+    print("Received form data:", form_data)
+    
+    # Process data and fill default values if needed
+    processed_data = {
+        'gender': gender if gender else 'Male',
+        'age': float(age) if age is not None else 0,
+        'hypertension': int(hypertension) if hypertension is not None else 0,
+        'heart_disease': int(heart_disease) if heart_disease is not None else 0,
+        'ever_married': ever_married if ever_married else 'No',
+        'work_type': work_type if work_type else 'Private',
+        'Residence_type': Residence_type if Residence_type else 'Urban',
+        'avg_glucose_level': float(avg_glucose_level) if avg_glucose_level is not None else 0,
+        'bmi': float(bmi) if bmi is not None else 0,
+        'smoking_status': smoking_status if smoking_status else 'never smoked'
+    }
+    print("Processed data for prediction:", processed_data)
+    
+    # Create a DataFrame from the processed data
+    input_df = pd.DataFrame([processed_data])
+    
+    # Prediction with fallback
     try:
-        # Try to use JSON data if provided
-        if formDataJson:
-            try:
-                raw_data = json.loads(formDataJson)
-                print(f"Received JSON data: {raw_data}")
-            except json.JSONDecodeError:
-                raise HTTPException(status_code=400, detail="Invalid JSON in formDataJson")
-        else:
-            # Build data dict from form fields with alternative field names
-            raw_data = {
-                "gender": gender,
-                "age": age,
-                "hypertension": hypertension,
-                "heart_disease": heart_disease if heart_disease is not None else heartDisease,
-                "ever_married": ever_married if ever_married is not None else everMarried,
-                "work_type": work_type if work_type is not None else workType,
-                "Residence_type": Residence_type if Residence_type is not None else residenceType,
-                "avg_glucose_level": avg_glucose_level if avg_glucose_level is not None else avgGlucoseLevel,
-                "bmi": bmi,
-                "smoking_status": smoking_status if smoking_status is not None else smokingStatus
-            }
-            print(f"Received form data: {raw_data}")
+        if model_info is None:
+            raise ValueError("Model not loaded")
+        
+        # Get prediction from model
+        prediction_proba = pipeline.predict_proba(input_df)[0][1]
+        prediction_binary = pipeline.predict(input_df)[0]
         
-        # Map frontend field names to model field names if needed
-        data = {}
+        # Calculate risk level
+        if prediction_proba < 0.1:
+            risk_level = "Very Low Risk"
+        elif prediction_proba < 0.3:
+            risk_level = "Low Risk"
+        elif prediction_proba < 0.6:
+            risk_level = "Moderate Risk"
+        else:
+            risk_level = "High Risk"
+            
+        # Identify risk factors
+        risk_factors = []
+        if processed_data['hypertension'] == 1:
+            risk_factors.append("Hypertension")
+        if processed_data['heart_disease'] == 1:
+            risk_factors.append("Heart Disease")
+        if processed_data['age'] > 65:
+            risk_factors.append("Advanced Age (65+)")
+        if processed_data['avg_glucose_level'] > 140:
+            risk_factors.append("High Blood Glucose (>140)")
+        if processed_data['bmi'] > 30:
+            risk_factors.append("Obesity (BMI > 30)")
+        if processed_data['smoking_status'] == 'formerly smoked':
+            risk_factors.append("Former Smoker")
+        if processed_data['smoking_status'] == 'smokes':
+            risk_factors.append("Current Smoker")
         
-        # Handle potential camelCase to snake_case conversions and field name differences
-        field_mappings = {
-            "gender": ["gender"],
-            "age": ["age"],
-            "hypertension": ["hypertension"],
-            "heart_disease": ["heart_disease", "heartDisease"],
-            "ever_married": ["ever_married", "everMarried"],
-            "work_type": ["work_type", "workType"],
-            "Residence_type": ["Residence_type", "residenceType"],
-            "avg_glucose_level": ["avg_glucose_level", "avgGlucoseLevel"],
-            "bmi": ["bmi"],
-            "smoking_status": ["smoking_status", "smokingStatus"]
+        # Return results
+        result = {
+            "probability": float(prediction_proba),
+            "prediction": risk_level,
+            "stroke_prediction": int(prediction_binary),
+            "risk_factors": risk_factors,
+            "using_model": True,
+            "execution_time_ms": (time.time() - start_time) * 1000,
+            "model_version": "stroke-prediction-1.0"
         }
         
-        # Fill data with the first available value from mappings
-        for model_field, possible_keys in field_mappings.items():
-            for key in possible_keys:
-                if key in raw_data and raw_data[key] is not None:
-                    data[model_field] = raw_data[key]
-                    break
+    except Exception as e:
+        print("Error in preprocessing:", e)
+        
+        # Fallback risk calculation
+        fallback_probability = 0.05  # Default low risk
+        
+        # Increase risk based on known factors
+        if processed_data['hypertension'] == 1:
+            fallback_probability += 0.1
+            
+        if processed_data['heart_disease'] == 1:
+            fallback_probability += 0.1
+            
+        if processed_data['age'] > 65:
+            fallback_probability += 0.15
+        elif processed_data['age'] > 55:
+            fallback_probability += 0.1
+            
+        if processed_data['avg_glucose_level'] > 180:
+            fallback_probability += 0.1
+        elif processed_data['avg_glucose_level'] > 140:
+            fallback_probability += 0.05
+            
+        if processed_data['bmi'] > 30:
+            fallback_probability += 0.05
+            
+        if processed_data['smoking_status'] == 'smokes':
+            fallback_probability += 0.07
+        elif processed_data['smoking_status'] == 'formerly smoked':
+            fallback_probability += 0.03
+            
+        # Cap at 80%
+        fallback_probability = min(fallback_probability, 0.8)
+        
+        # Determine risk level
+        if fallback_probability < 0.1:
+            risk_level = "Very Low Risk"
+        elif fallback_probability < 0.3:
+            risk_level = "Low Risk"
+        elif fallback_probability < 0.6:
+            risk_level = "Moderate Risk"
+        else:
+            risk_level = "High Risk"
             
-            # Use defaults for missing fields
-            if model_field not in data or data[model_field] is None:
-                if model_field in ["age", "avg_glucose_level", "bmi"]:
-                    data[model_field] = 0
-                elif model_field in ["hypertension", "heart_disease"]:
-                    data[model_field] = 0
-                elif model_field == "gender":
-                    data[model_field] = "Male"
-                elif model_field == "ever_married":
-                    data[model_field] = "No"
-                elif model_field == "work_type":
-                    data[model_field] = "Private"
-                elif model_field == "Residence_type":
-                    data[model_field] = "Urban"
-                elif model_field == "smoking_status":
-                    data[model_field] = "never smoked"
+        # Threshold for binary prediction
+        stroke_prediction = 1 if fallback_probability > 0.5 else 0
         
-        print(f"Processed data for prediction: {data}")
-
-        # Create a request object with our data
-        request = Request(scope={"type": "http"})
-        request._json = data
+        # Identify risk factors
+        risk_factors = []
+        if processed_data['hypertension'] == 1:
+            risk_factors.append("Hypertension")
+        if processed_data['heart_disease'] == 1:
+            risk_factors.append("Heart Disease")
+        if processed_data['age'] > 65:
+            risk_factors.append("Advanced Age (65+)")
+        if processed_data['avg_glucose_level'] > 140:
+            risk_factors.append("High Blood Glucose (>140)")
+        if processed_data['bmi'] > 30:
+            risk_factors.append("Obesity (BMI > 30)")
+        if processed_data['smoking_status'] == 'formerly smoked':
+            risk_factors.append("Former Smoker")
+        if processed_data['smoking_status'] == 'smokes':
+            risk_factors.append("Current Smoker")
         
-        # Pass to main prediction endpoint
-        result = await predict(request)
-        print(f"Prediction result: {result}")
-        return result
-    except Exception as e:
-        error_traceback = traceback.format_exc()
-        print(f"Error processing request: {str(e)}")
-        print(f"Traceback: {error_traceback}")
-        raise HTTPException(status_code=400, detail=f"Error processing request: {str(e)}")
+        result = {
+            "probability": fallback_probability,
+            "prediction": risk_level,
+            "stroke_prediction": stroke_prediction,
+            "risk_factors": risk_factors,
+            "using_model": False,
+            "execution_time_ms": (time.time() - start_time) * 1000,
+            "model_version": "fallback-1.0"
+        }
+    
+    print("Prediction result:", result)
+    return result
+
+@app.get("/")
+async def root():
+    return {"message": "Stroke Prediction API is running! Use /api/predict for predictions."}
 
+# Run the server
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860) 
+    uvicorn.run(app, host="0.0.0.0", port=7860)

model.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d4f68bdffeff53794d8c886eab70b97b1180e22985a6482869bac19fb60f5a29
-size 6057
+oid sha256:311ed211d2620c9b995f86949f49d53467cb8933678e858f98e671a93c4f4c09
+size 10381670

requirements.txt

@@ -1,8 +1,8 @@
-fastapi==0.103.1
-uvicorn==0.23.2
-python-multipart==0.0.6
-numpy==1.25.2
-pandas==2.0.3
-scikit-learn==1.3.0
-joblib==1.3.2
-requests==2.31.0 
+
+fastapi>=0.95.1
+uvicorn>=0.22.0
+pandas>=1.5.3
+numpy>=1.23.5
+scikit-learn>=1.2.2
+joblib>=1.2.0
+python-multipart>=0.0.6