Upload 12 files

.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+/.venv/

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.13-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt /app/requirements.txt
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code into the container
+COPY . /app
+
+# Expose ports for FastAPI and Streamlit
+EXPOSE 8000 8501
+
+# Command to run both FastAPI and Streamlit
+CMD ["sh", "-c", "uvicorn app:app --host 0.0.0.0 --port 8000 & streamlit run frontend.py --server.port 8501 --server.address 0.0.0.0"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Suresh Beekhani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,51 @@
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from schema.user_input import UserInput
+from schema.prediction_response import PredictionResponse
+from model.predict import predict_output, model, MODEL_VERSION
+import uvicorn
+
+app = FastAPI()
+
+# human readable       
+@app.get('/')
+def home():
+    return {'message':'Insurance Premium Prediction API'}
+
+# machine readable
+@app.get('/health')
+def health_check():
+    return {
+        'status': 'OK',
+        'version': MODEL_VERSION,
+        'model_loaded': model is not None
+    }
+
+@app.post('/predict', response_model=PredictionResponse)
+def predict_premium(data: UserInput):
+
+    user_input = {
+        'bmi': data.bmi,
+        'age_group': data.age_group,
+        'lifestyle_risk': data.lifestyle_risk,
+        'city_tier': data.city_tier,
+        'income_lpa': data.income_lpa,
+        'occupation': data.occupation
+    }
+
+    try:
+
+        prediction = predict_output(user_input)
+
+        return JSONResponse(status_code=200, content={'response': prediction})
+    
+    except Exception as e:
+
+        return JSONResponse(status_code=500, content=str(e))
+
+if __name__ == "__main__":
+    """
+    Run the FastAPI app using uvicorn.
+    """
+    uvicorn.run(app, host="127.0.0.1", port=8000, reload=True)
+# To run the app, use the command: uvicorn app:app --reload

config/city_tier.py

@@ -0,0 +1,9 @@
+tier_1_cities = ["Mumbai", "Delhi", "Bangalore", "Chennai", "Kolkata", "Hyderabad", "Pune"]
+tier_2_cities = [
+    "Jaipur", "Chandigarh", "Indore", "Lucknow", "Patna", "Ranchi", "Visakhapatnam", "Coimbatore",
+    "Bhopal", "Nagpur", "Vadodara", "Surat", "Rajkot", "Jodhpur", "Raipur", "Amritsar", "Varanasi",
+    "Agra", "Dehradun", "Mysore", "Jabalpur", "Guwahati", "Thiruvananthapuram", "Ludhiana", "Nashik",
+    "Allahabad", "Udaipur", "Aurangabad", "Hubli", "Belgaum", "Salem", "Vijayawada", "Tiruchirappalli",
+    "Bhavnagar", "Gwalior", "Dhanbad", "Bareilly", "Aligarh", "Gaya", "Kozhikode", "Warangal",
+    "Kolhapur", "Bilaspur", "Jalandhar", "Noida", "Guntur", "Asansol", "Siliguri"
+]

frontend.py

@@ -0,0 +1,52 @@
+import streamlit as st
+import requests
+
+API_URL = "http://127.0.0.1:8000" 
+
+st.title("Insurance Premium Category Predictor")
+st.markdown("Enter your details below:")
+
+# Input fields
+age = st.number_input("Age", min_value=1, max_value=119, value=30)
+weight = st.number_input("Weight (kg)", min_value=1.0, value=65.0)
+height = st.number_input("Height (m)", min_value=0.5, max_value=2.5, value=1.7)
+income_lpa = st.number_input("Annual Income (LPA)", min_value=0.1, value=10.0)
+smoker = st.selectbox("Are you a smoker?", options=[True, False])
+city = st.text_input("City", value="Mumbai")
+occupation = st.selectbox(
+    "Occupation",
+    ['retired', 'freelancer', 'student', 'government_job', 'business_owner', 'unemployed', 'private_job']
+)
+
+if st.button("Predict Premium Category"):
+    input_data = {
+        "age": age,
+        "weight": weight,
+        "height": height,
+        "income_lpa": income_lpa,
+        "smoker": smoker,
+        "city": city,
+        "occupation": occupation
+    }
+
+    try:
+        response = requests.post(API_URL + "/predict", json=input_data, timeout=10)
+        response.raise_for_status()  # Raise HTTPError for bad responses (4xx and 5xx)
+
+        result = response.json()
+        if "response" in result:
+            prediction = result["response"]
+            st.success(f"Predicted Insurance Premium Category: **{prediction['predicted_category']}**")
+            st.markdown(f"**Confidence:** {prediction['confidence']:.2f}")
+            st.markdown("### Class Probabilities:")
+            st.json(prediction["class_probabilities"])
+        else:
+            st.error("Unexpected response format from the API.")
+            st.json(result)
+
+    except requests.exceptions.ConnectionError:
+        st.error("❌ Could not connect to the FastAPI server. Please ensure it is running.")
+    except requests.exceptions.Timeout:
+        st.error("⏳ The request timed out. Please try again later.")
+    except requests.exceptions.RequestException as e:
+        st.error(f"⚠️ An error occurred: {e}")

model/model.pkl

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

model/predict.py

@@ -0,0 +1,32 @@
+import pickle
+import pandas as pd
+
+# import the ml model
+with open('model/model.pkl', 'rb') as f:
+    model = pickle.load(f)
+
+# MLFlow
+MODEL_VERSION = '1.0.0'
+
+# Get class labels from model (important for matching probabilities to class names)
+class_labels = model.classes_.tolist()
+
+def predict_output(user_input: dict):
+
+    df = pd.DataFrame([user_input])
+
+    # Predict the class
+    predicted_class = model.predict(df)[0]
+
+    # Get probabilities for all classes
+    probabilities = model.predict_proba(df)[0]
+    confidence = max(probabilities)
+    
+    # Create mapping: {class_name: probability}
+    class_probs = dict(zip(class_labels, map(lambda p: round(p, 4), probabilities)))
+
+    return {
+        "predicted_category": predicted_class,
+        "confidence": round(confidence, 4),
+        "class_probabilities": class_probs
+    }

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+pydantic
+requests
+streamlit
+pandas

schema/prediction_response.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, Field
+from typing import Dict
+
+class PredictionResponse(BaseModel):
+    predicted_category: str = Field(
+        ...,
+        description="The predicted insurance premium category",
+        example="High"
+    )
+    confidence: float = Field(
+        ...,
+        description="Model's confidence score for the predicted class (range: 0 to 1)",
+        example=0.8432
+    )
+    class_probabilities: Dict[str, float] = Field(
+        ...,
+        description="Probability distribution across all possible classes",
+        example={"Low": 0.01, "Medium": 0.15, "High": 0.84}
+    )

schema/user_input.py

@@ -0,0 +1,58 @@
+from pydantic import BaseModel, Field, computed_field, field_validator
+from typing import Literal, Annotated
+from config.city_tier import tier_1_cities, tier_2_cities
+
+
+# pydantic model to validate incoming data
+class UserInput(BaseModel):
+
+    age: Annotated[int, Field(..., gt=0, lt=120, description='Age of the user')]
+    weight: Annotated[float, Field(..., gt=0, description='Weight of the user')]
+    height: Annotated[float, Field(..., gt=0, lt=2.5, description='Height of the user')]
+    income_lpa: Annotated[float, Field(..., gt=0, description='Annual salary of the user in lpa')]
+    smoker: Annotated[bool, Field(..., description='Is user a smoker')]
+    city: Annotated[str, Field(..., description='The city that the user belongs to')]
+    occupation: Annotated[Literal['retired', 'freelancer', 'student', 'government_job',
+       'business_owner', 'unemployed', 'private_job'], Field(..., description='Occupation of the user')]
+    
+    @field_validator('city')
+    @classmethod
+    def normalize_city(cls, v: str) -> str:
+        v = v.strip().title()
+        return v
+    
+    @computed_field
+    @property
+    def bmi(self) -> float:
+        return self.weight/(self.height**2)
+    
+    @computed_field
+    @property
+    def lifestyle_risk(self) -> str:
+        if self.smoker and self.bmi > 30:
+            return "high"
+        elif self.smoker or self.bmi > 27:
+            return "medium"
+        else:
+            return "low"
+        
+    @computed_field
+    @property
+    def age_group(self) -> str:
+        if self.age < 25:
+            return "young"
+        elif self.age < 45:
+            return "adult"
+        elif self.age < 60:
+            return "middle_aged"
+        return "senior"
+    
+    @computed_field
+    @property
+    def city_tier(self) -> int:
+        if self.city in tier_1_cities:
+            return 1
+        elif self.city in tier_2_cities:
+            return 2
+        else:
+            return 3