Upload 33 files

backend/Dockerfile

@@ -0,0 +1,35 @@
+# docker/Dockerfile
+
+FROM python:3.11-slim
+
+ENV USER=uv-example-user \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    UV_PROJECT_ENVIRONMENT=/usr/local
+
+# Install required packages and dependencies
+RUN apt-get update && apt-get install --no-install-recommends -y \
+    curl \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* \
+    && useradd -m -s /bin/bash $USER
+
+# Set the working directory
+ENV APP_DIR=/home/$USER/src
+WORKDIR $APP_DIR
+
+# Copy application files
+COPY . $APP_DIR
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Set Python path
+ENV PYTHONPATH=$APP_DIR
+
+# Change ownership of the application directory
+RUN chown -R "$USER":"$USER" $APP_DIR
+USER $USER
+
+# Command to run the FastAPI app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

backend/app.py

@@ -0,0 +1,27 @@
+from fastapi import FastAPI
+from routes.home import router as home_router
+from routes.predict import router as predict_router
+from routes.auth import router as auth_router
+from database.database import engine, Base
+import uvicorn
+
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="Insurance Premium Prediction API with Auth")
+
+# Include routers
+app.include_router(home_router, prefix="/api", tags=["General"])
+app.include_router(predict_router, prefix="/api", tags=["Prediction"])
+app.include_router(auth_router, prefix="/api/auth", tags=["Authentication"])
+
+# Add a root endpoint
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to the Insurance Premium Prediction API"}
+
+if __name__ == "__main__":
+    """
+    Run the FastAPI app using uvicorn.
+    """
+    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)
+# To run the app, use the command: uvicorn app:app --reload

backend/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"
+]

backend/database/database.py

@@ -0,0 +1,11 @@
+# database.py
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+# Replace with your actual database URL
+DATABASE_URL = "sqlite:///./insurance.db"
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()

backend/model/model.pkl

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

backend/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
+    }

backend/models/user.py

@@ -0,0 +1,10 @@
+# models/user.py
+from sqlalchemy import Column, Integer, String
+from database.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    password = Column(String)

backend/models/utils.py

@@ -0,0 +1,20 @@
+# utils.py
+from passlib.context import CryptContext
+from jose import jwt
+from datetime import datetime, timedelta
+
+SECRET_KEY = "mysecret"
+ALGORITHM = "HS256"
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def hash_password(password: str):
+    return pwd_context.hash(password)
+
+def verify_password(plain: str, hashed: str):
+    return pwd_context.verify(plain, hashed)
+
+def create_token(data: dict, expires_minutes: int = 60):
+    data = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=expires_minutes)
+    data.update({"exp": expire})
+    return jwt.encode(data, SECRET_KEY, algorithm=ALGORITHM)

backend/requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+sqlalchemy
+pydantic
+requests
+passlib[bcrypt]
+pandas
+scikit-learn

backend/routes/auth.py

@@ -0,0 +1,38 @@
+# routes/auth.py
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from models.user import User
+from database.database import SessionLocal
+from schema.signloginRequest import SignupRequest, LoginRequest
+from passlib.context import CryptContext
+
+router = APIRouter()
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# Dependency to get DB session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+@router.post("/signup")
+def signup(request: SignupRequest, db: Session = Depends(get_db)):
+    if db.query(User).filter(User.username == request.username).first():
+        raise HTTPException(status_code=400, detail="Username already exists")
+    hashed_password = pwd_context.hash(request.password)
+    user = User(username=request.username, password=hashed_password)
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    return {"message": "User created successfully"}
+
+@router.post("/login")
+def login(request: LoginRequest, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.username == request.username).first()
+    if not user or not pwd_context.verify(request.password, user.password):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+    return {"message": "Login successful"}

backend/routes/home.py

@@ -0,0 +1,24 @@
+# routes/home.py
+from fastapi import APIRouter
+from model.predict import model, MODEL_VERSION
+
+# Create router
+router = APIRouter()
+
+@router.get("/")
+def home():
+    """
+    Human-readable welcome endpoint.
+    """
+    return {"message": "Insurance Premium Prediction API"}
+
+@router.get("/health")
+def health_check():
+    """
+    Machine-readable health check endpoint.
+    """
+    return {
+        "status": "OK",
+        "version": MODEL_VERSION,
+        "model_loaded": model is not None
+    }

backend/routes/predict.py

@@ -0,0 +1,33 @@
+# routes/predict.py
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import pandas as pd
+import pickle
+from schema.user_input import UserInput
+from schema.prediction_response import PredictionResponse 
+from model.predict import predict_output
+
+# Create router
+router = APIRouter()
+
+@router.post("/predict", response_model=PredictionResponse)
+def predict_premium(data: UserInput):
+    """
+    Predict insurance premium based on user input.
+    """
+    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={"error": str(e)})
+

backend/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}
+    )

backend/schema/signloginRequest.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+# Pydantic models for request validation
+class SignupRequest(BaseModel):
+    username: str
+    password: str
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str

backend/schema/user_input.py

@@ -0,0 +1,67 @@
+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
+# Pydantic model for input validation
+class PredictionInput(BaseModel):
+    age: int
+    weight: float
+    height: float
+    income_lpa: float
+    smoker: bool
+    city: str
+    occupation: str

docker-compose.yml

@@ -0,0 +1,28 @@
+version: "3.9"
+
+services:
+  backend:
+    build:
+      context: ./backend
+      dockerfile: Dockerfile
+    container_name: insurance-backend
+    ports:
+      - "8000:8000"
+    environment:
+      - PYTHONUNBUFFERED=1
+    volumes:
+      - ./backend:/home/uv-example-user/src
+    command: ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile
+    container_name: insurance-frontend
+    ports:
+      - "8501:8501"
+    environment:
+      - STREAMLIT_SERVER_PORT=8501
+    volumes:
+      - ./frontend:/app
+    command: ["streamlit", "run", "frontend.py", "--server.port=8501", "--server.address=0.0.0.0"]

frontend/Dockerfile

@@ -0,0 +1,20 @@
+# filepath: d:\Insurance Premium Predictor\frontend\Dockerfile
+FROM python:3.11-slim
+
+# Install required packages
+RUN apt-get update && apt-get install --no-install-recommends -y \
+    curl \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory
+WORKDIR /app
+
+# Copy application files
+COPY . /app
+
+# Upgrade pip and install Python dependencies
+RUN pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+# Command to run the Streamlit app
+CMD ["streamlit", "run", "frontend.py", "--server.port=8501", "--server.address=0.0.0.0"]

frontend/frontend.py

@@ -0,0 +1,105 @@
+import streamlit as st
+import requests
+
+# Update API_URL to use the backend service name
+API_URL = "http://127.0.0.1:8000" 
+st.set_page_config(page_title="Insurance Premium Predictor", layout="centered")
+
+# Resize title and subtitle
+st.markdown("<h1 style='text-align: center; font-size: 36px;'>Insurance Premium Category Predictor</h1>", unsafe_allow_html=True)
+st.markdown("<h3 style='text-align: center; font-size: 20px;'>Enter your details below to predict your insurance premium category:</h3>", unsafe_allow_html=True)
+
+# Session state to track login status
+if "logged_in" not in st.session_state:
+    st.session_state.logged_in = False
+
+# Sidebar for Authentication
+with st.sidebar:
+    st.markdown("## Authentication")
+    auth_mode = st.selectbox("Choose an option", ["Login", "Signup"], help="Select whether to log in or sign up.")
+
+    if auth_mode == "Login":
+        st.markdown("### Login")
+        login_username = st.text_input("Username", key="login_username", help="Enter your username.")
+        login_password = st.text_input("Password", type="password", key="login_password", help="Enter your password.")
+        if st.button("Login"):
+            login_data = {"username": login_username, "password": login_password}
+            try:
+                with st.spinner("Logging in..."):
+                    response = requests.post(API_URL + "/api/auth/login", json=login_data, timeout=10)
+                    response.raise_for_status()
+                    st.success("Login successful!")
+                    st.session_state.logged_in = True  # Set login status to True
+            except requests.exceptions.HTTPError as e:
+                st.error(f"Login failed: {response.json().get('detail', str(e))}")
+            except requests.exceptions.RequestException as e:
+                st.error(f"An error occurred: {e}")
+
+    elif auth_mode == "Signup":
+        st.markdown("### Signup")
+        signup_username = st.text_input("Signup Username", key="signup_username", help="Enter a unique username.")
+        signup_password = st.text_input("Signup Password", type="password", key="signup_password", help="Enter a secure password.")
+        if st.button("Signup"):
+            signup_data = {"username": signup_username, "password": signup_password}
+            try:
+                with st.spinner("Creating account..."):
+                    response = requests.post(API_URL + "/api/auth/signup", json=signup_data, timeout=10)
+                    response.raise_for_status()
+                    st.success("Account created successfully! You can now log in.")
+            except requests.exceptions.HTTPError as e:
+                st.error(f"Signup failed: {response.json().get('detail', str(e))}")
+            except requests.exceptions.RequestException as e:
+                st.error(f"An error occurred: {e}")
+
+# Show Prediction Section only if logged in
+if st.session_state.logged_in:
+    # Display all input fields in a single column
+    age = st.number_input("Age", min_value=1, max_value=119, value=30, help="Enter your age in years.")
+    weight = st.number_input("Weight (kg)", min_value=1.0, value=65.0, help="Enter your weight in kilograms.")
+    height = st.number_input("Height (m)", min_value=0.5, max_value=2.5, value=1.7, help="Enter your height in meters.")
+    income_lpa = st.number_input("Annual Income (LPA)", min_value=0.1, value=10.0, help="Enter your annual income in lakhs per annum.")
+    smoker = st.selectbox("Are you a smoker?", options=["Yes", "No"], help="Select 'Yes' if you are a smoker, otherwise 'No'.")
+    city = st.text_input("City", value="Mumbai", help="Enter the city you reside in.")
+    occupation = st.selectbox(
+        "Occupation",
+        ['retired', 'freelancer', 'student', 'government_job', 'business_owner', 'unemployed', 'private_job'],
+        help="Select your occupation from the dropdown."
+    )
+
+    # Submit button for Prediction
+    if st.button("Predict Premium Category"):
+        input_data = {
+            "age": age,
+            "weight": weight,
+            "height": height,
+            "income_lpa": income_lpa,
+            "smoker": smoker.lower() == "yes",
+            "city": city,
+            "occupation": occupation
+        }
+
+        try:
+            with st.spinner("Predicting..."):
+                # Increased timeout to 30 seconds
+                response = requests.post(API_URL + "/api/predict", json=input_data, timeout=30)
+                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}")
+else:
+    st.warning("Please log in to access the prediction feature.")

frontend/requirements.txt

@@ -0,0 +1,7 @@
+streamlit==1.45.1
+pandas
+requests
+altair==5.5.0
+numpy
+python-dateutil
+pytz