Upload 91 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+test_data/customer_churn_dataset-training-master.csv filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,14 @@
+# Dockerfile for all services
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+
+# Expose port
+EXPOSE 8001  
+EXPOSE 8501  
+

README.md

@@ -1,13 +1,207 @@
----
-title: Streamlitwebapp
-emoji: 📉
-colorFrom: blue
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.40.1
-app_file: app.py
-pinned: false
-short_description: 'streamli app '
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# End to End Customer Churn Prediction 
+
+## :page_facing_up: Problem Statement
+Customer churn is a critical issue for businesses as it directly impacts profitability and growth. This application aims to predict whether a customer will leave a service or product based on historical data and behavioral patterns.
+
+## :dart: Objective
+The main objective of this application is to develop a machine learning model that accurately predicts customer churn. By identifying at-risk customers, businesses can take proactive measures to enhance customer retention and improve overall satisfaction.
+
+## 🛠️ Technological Stack
+- **Python** -  The primary programming language used for development.
+- **Machine Learning** - Algorithms to analyze customer data and predict churn.
+- **MLOps** - Practices for deploying and maintaining machine learning models.
+- **ZenML** -  A tool to create reproducible ML pipelines.
+- **MLflow** -  For tracking experiments and managing model lifecycle.
+- **Streamlit** -  A user-friendly UI framework for creating interactive web applications.
+- **FastAPI** - Back-end frameworks to build APIs for model prediction server.
+- **Evidently Ai** - A tool for Model Monitering and data drift detection.
+
+## 📝 Overview
+This design document outlines the development of a web application for predicting customer churn using a dataset that includes customer Age, Support Calls , Usage Frequency, Last Interaction, Tenure, Contract Length. The application will allow users to input customer data and receive predictions on churn likelihood.
+
+
+## :snake: Python Requirements 
+Let's jumpt into python packages you need. you need run below commands in python enivironmemt
+
+```
+mkdir customer_churn_prediction
+
+cd customer_churn_prediction
+
+git clone https://github.com/sarathkumar1304/End-to-End-Customer-Churn-Prediction
+
+python3 -m venv venv
+```
+
+Activate your virtual environment
+
+```pip install requirements.txt```
+
+
+
+Starting with **ZenML** an open source MLOPs Library for machine learning engineer life cycle.ZenML has react base dashboard that allows you to observe your pipeline DAG's, stacks, stack components in dashboard interface.
+
+To access this, you need to launch  the ZenML Server and Dashboard locally, we need run run below commands
+
+
+```
+pip install zenml["server"]
+
+zenml up
+```
+
+After running this commands we can visualize the dashboard locally in your browser.
+
+
+Then , you run the pipeline first and then follow the steps.
+
+```
+python3 run_pipeline.py
+```
+
+run_pipeline.py has all the combined python scripts to run the pipeline at one place.Now we can visualize the pipeline in your web browser.
+
+we can the dashboard like below 
+![datapipeline-image](assets/datapipeline.png)
+
+
+
+
+Before the deployment we need run some commands, to intergrate with **MLFlow** for Experiment trackering  and model registry.
+
+```
+zenml integration install mlflow -y
+
+zenml experiment-tracker register mlflow_tracker --flavor=mlflow
+
+zenml model-deployer register mlflow_customer_churn --flavor=mlflow
+
+zenml stack register mlflow_stack_customer_churn -a default -o default -d mlflow -e mlflow_tracker_customer_churn --set
+```
+
+![datapipeline-2](assets/datapipeline-2.png)
+
+![datapipeline-3](assets/datapipeline-3.png)
+
+After running this command we can track the experiment in mlflow dashboard locally.
+
+```
+python3 run_deployment.py
+```
+
+
+After running this command we  successfully deploy the model in mlflow server that returns this url for further prediction  http://127.0.0.1:8000/invocations for further predicition.
+
+Run the below command to launch the streamlit ui.
+
+```
+streamlit run frontend/main.py
+```
+
+or we can run whole project using **Docker** by running the below command 
+
+```
+docker-compose up --build 
+```
+ It will run the whole project at once without any error.
+
+
+
+## 💪 Motivation
+Understanding and addressing customer churn can significantly enhance customer loyalty and reduce marketing costs associated with acquiring new customers. This application provides insights that help businesses to implement effective retention strategies.
+
+## 📈 Success Metrics
+The project's success will be measured using the following metrics:
+- Precision, Recall, and F1 Score of the churn prediction model.
+- Reduction in customer churn rates observed post-implementation.
+
+## 📑 Requirements & Constraints
+### Functional Requirements
+- Users can input customer data to receive churn predictions.
+- Users can view performance metrics of the machine learning models.
+- The model should demonstrate high accuracy in predictions.
+
+### 🚧 Constraints
+- The application is built using FastAPI as backend and Streamlit as front end , with deployment on Streamlit cloud  and Containerizer using Docker
+
+## ⚙️ Methodology
+- **Problem Statement**: Develop a model to predict customer churn based on various features.
+- **Data**: Utilize a dataset containing customer-related features such as demographics and service usage.
+- **Techniques**: Employ data ingestion,  data preprocessing, feature engineering, model selection, training,  evaluation and model deployment.
+- **zenml :** for  creating reproducible ML pipeline.
+- **MLFlow:** for experiment tracking and model registry.
+- **Docker :** for containerization the whole project.
+
+## 🏛️ Architecture
+The architecture of the web application consists of:
+- A **frontend** built using Streamlit for user interaction.
+- A **backend** server implemented with FastAPI for handling requests and serving predictions.
+- A **machine learning model** for churn prediction.
+- Utilization of **Docker** for containerization.
+- Hosting on **Streamlit Cloud** with a CI/CD pipeline for automated deployment.
+
+
+## 🖇️ Pipeline 
+
+![Image](assets/Pipeline.png)
+
+The MLOps (Machine Learning Operations) pipeline project is designed to create an end-to-end workflow for developing and deploying a web application that performs data preprocessing, model training, model evaluation, and prediction. The pipeline leverages Docker containers for encapsulating code, artifacts, and both the frontend and backend components of the application. The application is deployed on a Streamlit  to provide a cloud hosting solution.
+
+The pipeline follows the following sequence of steps:
+
+**Data Ingestion**: The pipeline starts with the input data, which is sourced from a specified location. It can be in the form of a CSV file.
+
+**Preprocessing:** The data undergoes preprocessing steps to clean, transform, and prepare it for model training. This stage handles tasks such as missing value imputation, feature scaling, and categorical variable encoding.
+
+**Model Training:** The preprocessed data is used to train machine learning models. The pipeline supports building multiple models, allowing for experimentation and comparison of different algorithms or hyperparameters.
+
+**Model Evaluation:** The trained models are evaluated using appropriate evaluation metrics to assess their performance. This stage helps in selecting the best-performing model for deployment.
+
+**Docker Container:** The pipeline utilizes Docker containers to package the application code, model artifacts, and both the frontend and backend components. This containerization ensures consistent deployment across different environments and simplifies the deployment process.
+
+**Streamlit:** The Docker container, along with the required dependencies, is deployed on a  droplet Streamlit. Streamlit provides a cloud hosting solution that allows for scalability, reliability, and easy management of the web application.
+
+**Web App:** The web application is accessible via a web browser, providing a user-friendly interface for interacting with the prediction functionality. Users can input new data and obtain predictions from the deployed model.
+
+**Prediction:** The deployed model uses the input data from the web application to generate predictions. These predictions are then displayed to the user via the web interface.
+
+**Evidently AI :** A tools for model monitering and data drifting detection when new data comes in. 
+
+**CI/CD Pipeline:** The pipeline is automated using GitHub Actions, which allows for continuous integration and deployment of the application. This automation ensures that the application is always up-to-date and provides a consistent experience for users.
+
+### 🕹️ Streamlit App 
+
+There is a live demo of this project using Streamlit which you can find [here](https://end-to-end-customer-churn-prediction-9en8mwgk9xqgy8z7envfmm.streamlit.app/) 
+
+## Video
+
+## Project Video
+
+Check out the demo of my project on YouTube: [Watch Video](https://youtu.be/Nj-ICiTPJYA?si=EUfhNkFQ3PF47V25) below
+
+[![Project Video](assets/customer.webp)](https://youtu.be/Nj-ICiTPJYA?si=EUfhNkFQ3PF47V25)
+
+<if
+
+
+## Data Report 
+
+### Data Drift Detection using Evidently ai 
+
+![image](assets/datadrift.png)
+
+![image](assets/datadrift-2.png)
+
+
+![image](assets/datadrift-3.png)
+
+
+## Classification Perfomance using Evidently AI
+
+![image](assets/classificationperformance.png)
+
+
+![image](assets/classificationperfomance-2.png)
+
+![image](assets/classificationperfomance-3.png)
+

assets/model_metrics.csv

@@ -0,0 +1,5 @@
+Model,Accuracy,Precision,Recall,F1 Score
+Logistic Regression,0.8507372400756144,0.8520515900889458,0.8507372400756144,0.8510765294974902
+Random Forest,0.9996219281663516,0.999622210747845,0.9996219281663516,0.9996219462806213
+Decision Tree,0.9996975425330813,0.9996975550375765,0.9996975425330813,0.9996975450588826
+XGBoost,0.9998714555765595,0.9998714937956894,0.9998714555765595,0.9998714578564856

backend/artifacts/Decision Tree.pkl

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

backend/artifacts/Logistic Regression.pkl

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

backend/artifacts/Random Forest.pkl

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

backend/artifacts/XGBoost.pkl

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

backend/config/config.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+REPORTS_DIR = BASE_DIR / "reports"
+ARTIFACTS_DIR = BASE_DIR / "artifacts"
+DATA_DIR = BASE_DIR / "test_data"
+
+REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+ARTIFACTS_DIR.mkdir(parents=True, exist_ok=True)
+

backend/fastapi_app.py

@@ -0,0 +1,36 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import requests
+import pandas as pd
+
+app = FastAPI()
+
+# Define the structure of the incoming data
+class InputData(BaseModel):
+    dataframe_records: list[dict]  # List of dictionaries (like rows in a DataFrame)
+
+# Define endpoint to receive data and make a prediction
+@app.post("/predict")
+async def make_prediction(input_data: InputData):
+    # URL for MLflow's prediction server
+    mlflow_url = "http://127.0.0.1:8000/invocations"
+    headers = {"Content-Type": "application/json"}
+
+    # Prepare the JSON data to send to MLflow
+    json_data = {
+        "dataframe_records": input_data.dataframe_records
+    }
+
+    try:
+        # Send data to MLflow and get prediction
+        response = requests.post(mlflow_url, headers=headers, json=json_data)
+        response.raise_for_status()  # Raise an error for a failed request
+        return response.json()  # Return MLflow's prediction result
+
+    except requests.exceptions.HTTPError as err:
+        raise HTTPException(status_code=response.status_code, detail=str(err))
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# uvicorn backend.fastapi_app:app --port 8001

backend/train_and_evaluate.py

@@ -0,0 +1,87 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+from xgboost import XGBClassifier
+import logging
+import joblib
+from config.config import REPORTS_DIR,ARTIFACTS_DIR
+
+
+# Configure logging
+logging.basicConfig(
+    filename='/home/sarath_kumar/customer_chrun_prediction/training_log.log',
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+logging.info("Starting training script...")
+
+try:
+    
+    data = pd.read_csv("/home/sarath_kumar/customer_chrun_prediction/processed_data/processed_data.csv")
+    logging.info("Dataset loaded successfully.")
+
+   
+    X = data.drop('Churn', axis=1)
+    y = data['Churn']
+    logging.info("Data split into features and target.")
+
+   
+    models = {
+        "Logistic Regression": LogisticRegression(max_iter=500,solver='saga'),
+        "Random Forest": RandomForestClassifier(),
+        "Decision Tree": DecisionTreeClassifier(),
+        "XGBoost": XGBClassifier(),
+    }
+
+    
+    metrics_list = []
+
+    
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+    logging.info("Data split into training and testing sets.")
+
+    for model_name, model in models.items():
+        logging.info(f"Training {model_name}...")
+        model.fit(X_train, y_train)
+        logging.info(f"{model_name} training completed.")
+
+        y_pred = model.predict(X_test)
+        logging.info(f"{model_name} prediction completed.")
+
+    
+        accuracy = accuracy_score(y_test, y_pred)
+        precision = precision_score(y_test, y_pred, average='weighted')
+        recall = recall_score(y_test, y_pred, average='weighted')
+        f1 = f1_score(y_test, y_pred, average='weighted')
+
+        logging.info(f"{model_name} evaluation metrics calculated.")
+
+        
+        metrics_list.append({
+            "Model": model_name,
+            "Accuracy": accuracy,
+            "Precision": precision,
+            "Recall": recall,
+            "F1 Score": f1
+        })
+
+    metrics_df = pd.DataFrame(metrics_list)
+    logging.info("Metrics DataFrame created.")
+    metrics_df.to_csv(REPORTS_DIR / "model_metrics.csv", index=False)
+    logging.info("Metrics saved to CSV successfully.")
+
+
+    
+    for model_name, model in models.items():
+        joblib.dump(model, ARTIFACTS_DIR/ f"{model_name}.pkl")
+        logging.info(f"{model_name} saved to file.")
+
+    logging.info("Training script completed successfully.")
+
+except Exception as e:
+    logging.error(f"An error occurred: {e}")
+    raise

data/customer_churn_dataset-training-master.csv.zip

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

docker-compose.yml

@@ -0,0 +1,71 @@
+version: "3.8"
+
+services:
+  # Step 1: Run Deployment
+  deployment:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: >
+      bash -c "
+      zenml init &&
+      zenml integration install mlflow -y &&
+      zenml experiment-tracker register mlflow_tracker_customer_churn_new --flavor=mlflow &&
+      zenml model-deployer register mlflow_customer_churn_new --flavor=mlflow &&
+      zenml stack register mlflow_stack_customer_churn_new -a default -o default -d mlflow -e mlflow_tracker_customer_churn_new --set &&
+      zenml stack set mlflow_stack_customer_churn_new &&
+      python3 run_pipeline.py&&
+      python3 run_deployment.py
+      "
+    volumes:
+      - .:/app
+    working_dir: /app
+    restart: on-failure
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]  # Adjust URL for deployment health check
+      interval: 10s
+      retries: 3
+      start_period: 5s
+      timeout: 5s
+
+  # Step 2: Run FastAPI service after Deployment is completed
+  fastapi_service:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: ["uvicorn", "backend.fastapi_app:app", "--host", "0.0.0.0", "--port", "8001"]
+    depends_on:
+      - deployment
+    volumes:
+      - .:/app
+    working_dir: /app
+    ports:
+      - "8001:8001"
+    restart: on-failure
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8001/health"]  # Adjust URL for FastAPI health check
+      interval: 10s
+      retries: 3
+      start_period: 5s
+      timeout: 5s
+
+  # Step 3: Run Streamlit UI after FastAPI service is up
+  streamlit:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: ["streamlit", "run", "frontend/main.py"]
+    depends_on:
+      - fastapi_service
+    volumes:
+      - .:/app
+    working_dir: /app
+    ports:
+      - "8501:8501"
+    restart: on-failure
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8501/health"]  # Adjust URL for Streamlit health check
+      interval: 10s
+      retries: 3
+      start_period: 5s
+      timeout: 5s

frontend/EDA.py

@@ -0,0 +1,82 @@
+import streamlit as st
+import pandas as pd
+from analysis import univariate_analysis, BivariateAnalysis, multivariate_analysis
+
+def eda():
+    st.image("/home/sarath_kumar/customer_churn_predict/assets/eda.webp",width=300)
+    st.title("Exploratory Data Analysis")
+
+    
+    data = pd.read_csv("extracted/customer_churn_dataset-training-master.csv")
+    data.drop("CustomerID",axis = 1,inplace = True)
+  
+    data.dropna(axis=0,inplace = True,how = "all")
+    st.header("Dataset Overview")
+    st.dataframe(data.head())
+
+   
+    st.subheader("Select Analysis Type")
+    analysis_type = st.selectbox(
+        "Select Analysis Type",
+        ["Univariate Analysis", "Bivariate Analysis", "Multivariate Analysis"]
+    )
+
+    if analysis_type == "Univariate Analysis":
+        st.subheader("Univariate Analysis")
+        column = st.selectbox("Select a column for univariate analysis", data.columns, key="uni")
+        plot_type = st.selectbox("Select plot type", ["Histogram", "Boxplot", "Pie Chart", "Bar Plot"], key="uni_plot")
+
+      
+        if st.button("Generate Univariate Plot", key="uni_button"):
+            if column:
+                univariate_analysis(data, column, plot_type)
+            else:
+                st.warning("Please select a column for analysis.")
+
+    elif analysis_type == "Bivariate Analysis":
+        st.subheader("Bivariate Analysis")
+        column_x = st.selectbox("Select X-axis column", data.columns, key="bi_x")
+        column_y = st.selectbox("Select Y-axis column", data.columns, key="bi_y")
+        plot_type = st.selectbox("Select plot type", ["Scatter Plot", "Bar Plot", "Boxplot"], key="bi_plot")
+
+        if st.button("Generate Bivariate Plot", key="bi_button"):
+        
+            if pd.api.types.is_numeric_dtype(data[column_x]) and pd.api.types.is_numeric_dtype(data[column_y]):
+                analysis = BivariateAnalysis()
+                analysis.numerical_vs_numerical(data, column_x, column_y, plot_type)
+            elif pd.api.types.is_categorical_dtype(data[column_x]) and pd.api.types.is_categorical_dtype(data[column_y]): 
+                analysis = BivariateAnalysis()
+                analysis.numerical_vs_categorical(data, column_x, column_y, plot_type)
+            elif pd.api.types.is_numeric_dtype(data[column_x]) and pd.api.types.is_categorical_dtype(data[column_y]):
+                analysis = BivariateAnalysis()
+                analysis.numerical_vs_categorical(data, column_x, column_y, plot_type)
+            elif pd.api.types.is_categorical_dtype(data[column_x]) and pd.api.types.is_numeric_dtype(data[column_y]):
+                analysis = BivariateAnalysis()
+                analysis.numerical_vs_categorical(data, column_x, column_y, plot_type)
+            elif pd.api.types.is_numeric_dtype(data[column_x]) and pd.api.types.is_numeric_dtype(data[column_y]):
+                analysis = BivariateAnalysis()
+                analysis.numerical_vs_numerical(data, column_x, column_y, plot_type)
+            else:
+                st.warning("Please select numerical columns for analysis. Only numerical data types are supported for this plot.")
+
+    elif analysis_type == "Multivariate Analysis":
+        data = pd.read_csv("/home/sarath_kumar/customer_chrun_prediction/processed_data/processed_data.csv")
+        st.subheader("Multivariate Analysis")
+        columns = st.multiselect("Select columns for multivariate analysis", data.columns)
+
+        # Add an option for users to select the type of plot
+        plot_type = st.selectbox(
+            "Select plot type for multivariate analysis",
+            ["Correlation Heatmap", "Scatter Matrix"]
+        )
+
+       
+        if st.button("Generate Multivariate Plot", key="multi_button"):
+            if columns:
+                
+                multivariate_analysis(data, columns, plot_type)
+            else:
+                st.warning("Please select columns for multivariate analysis.")
+
+if __name__ == "__main__":
+    eda()

frontend/about.py

@@ -0,0 +1,24 @@
+import streamlit as st
+
+
+def about_me():
+    st.title("About Me 🙋‍♂️ ")
+    st.write("""
+Hello! 👋 I'm **R. Sarath Kumar**, and I'm thrilled to have you here! I’m a dedicated and passionate professional in **Data Science** and **Machine Learning** 🤖.  
+With a strong foundation in statistics, machine learning, and MLOps, I love transforming data into valuable insights and building predictive models that solve real-world problems. My work spans across multiple domains, and I’m always excited to explore new tools and techniques to make data-driven decisions more effective and impactful.
+
+Feel free to browse through my projects, where you’ll find some of the most exciting applications of AI and machine learning, and don't hesitate to reach out if you’d like to connect or discuss potential collaborations!
+""")
+
+
+
+    st.subheader("Contact Information")
+    
+    
+    st.write("🔗LinkedIn: [LinkedIn](https://www.linkedin.com/in/r-sarath-kumar-666084257)") 
+    st.write("🔗Github:[Github](https://www.github.com/sarathkumar1304)") 
+
+    
+    st.write("📧 Email: [[email protected]](mailto:[email protected])")  
+    
+    st.write("📞 Phone: 7780651312")  

frontend/analysis.py

@@ -0,0 +1,239 @@
+import plotly.express as px
+import streamlit as st
+import pandas as pd
+import numpy as np
+import itertools
+from scipy.stats import pearsonr, pointbiserialr
+from sklearn.ensemble import RandomForestClassifier
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+# def univariate_analysis(data, column, plot_type):
+#     if plot_type == "Histogram":
+#         if data[column].dtype=="int64" or data[column].dtype=="float64":
+#             fig = px.histogram(data, x=column, title=f'Histogram of {column}')
+#             st.plotly_chart(fig)
+#         else:
+#             st.warning("Histograms are only suitable for numerical columns.")
+
+#     elif plot_type == "Boxplot":
+#         if data[column].dtype=="int64" or data[column].dtype=="float64":
+#             fig = px.box(data, y=column, title=f'Boxplot of {column}')
+#             st.plotly_chart(fig)
+#         else:
+#             st.warning("Boxplots are only suitable for numerical columns.")
+#     elif plot_type == "Pie Chart":
+#         if data[column].dtype == 'object' or pd.api.types.is_categorical_dtype(data[column]):
+#             fig = px.pie(data, names=column, title=f'Pie Chart of {column}')
+#             st.plotly_chart(fig)
+#         else:
+#             st.warning("Pie charts are only suitable for categorical columns.")
+#     elif plot_type == "Bar Plot":
+#         if data[column].dtype == 'object' or pd.api.types.is_categorical_dtype(data[column]):
+#             fig = px.bar(data[column].value_counts().reset_index(), x='index', y=column, title=f'Bar Plot of {column}')
+#             st.plotly_chart(fig)
+#         else:
+#             st.warning("Bar plots are only suitable for categorical columns.")
+
+import pandas as pd
+import plotly.express as px
+import streamlit as st
+
+def univariate_analysis(data, column, plot_type):
+    if plot_type == "Histogram":
+        if data[column].dtype == "int64" or data[column].dtype == "float64":
+            fig = px.histogram(data, x=column, title=f'Histogram of {column}')
+            st.plotly_chart(fig)
+        else:
+            st.warning("Histograms are only suitable for numerical columns.")
+
+    elif plot_type == "Boxplot":
+        if data[column].dtype == "int64" or data[column].dtype == "float64":
+            fig = px.box(data, y=column, title=f'Boxplot of {column}')
+            st.plotly_chart(fig)
+        else:
+            st.warning("Boxplots are only suitable for numerical columns.")
+            
+    elif plot_type == "Pie Chart":
+        if data[column].dtype == 'object' or pd.api.types.is_categorical_dtype(data[column]):
+            fig = px.pie(data, names=column, title=f'Pie Chart of {column}')
+            st.plotly_chart(fig)
+        else:
+            st.warning("Pie charts are only suitable for categorical columns.")
+            
+    elif plot_type == "Bar Plot":
+        if data[column].dtype == 'object' or pd.api.types.is_categorical_dtype(data[column]):
+            # Get value counts and reset index, then rename columns for Plotly
+            data_count = data[column].value_counts().reset_index()
+            data_count.columns = ['index', column]  # Renaming columns
+            
+            fig = px.bar(data_count, x='index', y=column, title=f'Bar Plot of {column}')
+            st.plotly_chart(fig)
+        else:
+            st.warning("Bar plots are only suitable for categorical columns.")
+
+
+# def multivariate_analysis(data, columns):
+#     fig = px.scatter_matrix(data, dimensions=columns, title=f'Multivariate Analysis')
+#     st.plotly_chart(fig)
+
+
+def multivariate_analysis(data, columns, plot_type):
+    if plot_type == "Correlation Heatmap":
+        st.subheader("Correlation Heatmap")
+        if len(columns) > 1:
+            # Compute the correlation matrix
+            correlation_matrix = data[columns].corr()
+
+            # Create a heatmap using Seaborn and Matplotlib
+            fig, ax = plt.subplots(figsize=(10, 8))
+            sns.heatmap(correlation_matrix, annot=True, cmap="coolwarm", vmin=-1, vmax=1, ax=ax)
+            st.pyplot(fig)
+        else:
+            st.warning("Please select at least two columns for a correlation heatmap.")
+
+    elif plot_type == "Scatter Matrix":
+        st.subheader("Scatter Matrix Plot")
+        if len(columns) > 1:
+            fig = px.scatter_matrix(data, dimensions=columns, title='Scatter Matrix Plot')
+            st.plotly_chart(fig)
+        else:
+            st.warning("Please select at least two columns for a scatter plot matrix.")
+
+
+
+class BivariateAnalysis:
+    def numerical_vs_numerical(self, data, column_x, column_y, plot_type):
+        plt.figure(figsize=(10, 6))
+        if plot_type == "Scatter Plot":
+            if data[column_x].dtype == 'int64' or data[column_x].dtype == 'float64' and data[column_y].dtype == 'int64' or data[column_y].dtype == 'float64':
+                sns.scatterplot(data=data, x=column_x, y=column_y)
+                plt.title(f'Scatter Plot of {column_x} vs {column_y}')
+            else:
+                st.warning("Scatter plots are only suitable for numerical columns.")
+
+        elif plot_type == "Bar Plot":
+            if data[column_x].dtype == 'object' or pd.api.types.is_categorical_dtype(data[column_x]) and data[column_y].dtype == 'object' or pd.api.types.is_categorical_dtype(data[column_y]):
+                sns.barplot(data=data, x=column_x, y=column_y)
+                plt.title(f'Bar Plot of {column_x} vs {column_y}')
+            else:
+                st.warning("Bar plots are only suitable for categorical columns.")
+        elif plot_type == "Boxplot":
+            if data[column_x].dtype == 'int64' or data[column_x].dtype == 'float64' and data[column_y].dtype == 'int64' or data[column_y].dtype == 'float64':
+                sns.boxplot(data=data, x=column_x, y=column_y)
+                plt.title(f'Boxplot of {column_x} vs {column_y}')
+            else:
+                st.warning("Boxplots are only suitable for numerical columns.")
+        st.pyplot(plt.gcf())
+        plt.clf()  
+
+
+    
+    def numerical_vs_categorical(df, categorical_feature='Churn'):
+        numerical_features = df.select_dtypes(include=[float, int]).columns
+        if df[categorical_feature].nunique() != 2:
+            print(f"The categorical feature '{categorical_feature}' is not binary. Skipping correlation calculation.")
+            for feature in numerical_features:
+                fig = px.box(
+                    df, x=categorical_feature, y=feature, color=categorical_feature,
+                    title=f"Box Plot of {feature} by {categorical_feature}",
+                    labels={categorical_feature: categorical_feature, feature: feature}
+                )
+                fig.update_layout(
+                    xaxis_title=categorical_feature,
+                    yaxis_title=feature,
+                    hovermode="x unified"
+                )
+                fig.show()
+            return
+
+        df[categorical_feature] = pd.factorize(df[categorical_feature])[0]
+        for feature in numerical_features:
+            valid_data = df[[feature, categorical_feature]].dropna()
+            valid_data[feature] = pd.to_numeric(valid_data[feature], errors='coerce').dropna()
+            correlation, _ = pointbiserialr(valid_data[feature], valid_data[categorical_feature])
+            title = f"Box Plot of {feature} by {categorical_feature} (Correlation: {correlation:.2f})"
+            fig = px.box(
+                valid_data, x=categorical_feature, y=feature, color=categorical_feature,
+                title=title,
+                labels={categorical_feature: categorical_feature, feature: feature}
+            )
+            fig.update_layout(
+                xaxis_title=categorical_feature,
+                yaxis_title=feature,
+                hovermode="x unified"
+            )
+            fig.show()
+
+    
+    def numerical_vs_target(df, target='Churn'):
+        numerical_features = df.select_dtypes(include=[float, int]).columns
+        for feature in numerical_features:
+            fig = px.box(
+                df, 
+                x=target,  
+                y=feature,  
+                color=target,  
+                title=f"Distribution of {feature} by {target} Status",
+                labels={target: f"{target} Status", feature: feature}
+            )
+            fig.update_layout(
+                xaxis_title=f"{target} Status",
+                yaxis_title=feature,
+                legend_title=target,
+                hovermode="x unified"
+            )
+            fig.show()
+
+    
+    def categorical_vs_target(df, target='Churn'):
+        categorical_features = df.select_dtypes(include=[object]).columns
+        for feature in categorical_features:
+            crosstab_data = pd.crosstab(df[feature], df[target])
+            crosstab_df = crosstab_data.reset_index().melt(id_vars=feature, value_name="Count")
+            fig = px.bar(
+                crosstab_df, 
+                x=feature, 
+                y="Count", 
+                color=target,
+                title=f"{target} by {feature}",
+                labels={feature: feature, "Count": "Count", target: f"{target} Status"},
+                text="Count",
+                barmode="group"
+            )
+            fig.update_layout(
+                xaxis_title=feature,
+                yaxis_title="Count",
+                legend_title=target,
+                hovermode="x unified"
+            )
+            fig.show()
+
+    def feature_importance(df, target_column):
+        X = df.drop(columns=[target_column])
+        y = df[target_column]
+
+        model = RandomForestClassifier(random_state=0)
+        model.fit(X.select_dtypes(include=[np.number]), y)
+
+        importance_df = pd.DataFrame({
+            "Feature": X.select_dtypes(include=[np.number]).columns,
+            "Importance": model.feature_importances_
+        }).sort_values(by="Importance", ascending=True)
+
+        fig_importance = px.bar(
+            importance_df,
+            x="Importance",
+            y="Feature",
+            title="Feature Importance",
+            orientation="h",
+            color="Importance",
+            color_continuous_scale="Viridis",
+        )
+        fig_importance.update_layout(
+            title_font=dict(size=20),
+            xaxis_title="Importance Score",
+            yaxis_title="Features",
+            font=dict(size=12),
+        )
+        fig_importance.show()

frontend/home.py

@@ -0,0 +1,95 @@
+import streamlit as st
+
+def home_page():
+    st.image("assets/customer.webp")
+    
+    st.title("Customer Churn Prediction Application 🌐 ")
+    
+    st.header("📝 Problem Statement")
+    st.write("""
+    Customer churn is a critical issue for businesses as it directly impacts profitability and growth. This application aims to predict whether a customer will leave a service or product based on historical data and behavioral patterns. 
+    """)
+
+    
+    st.header(" 🎯 Objective")
+    st.write("""
+    The main objective of this application is to develop a machine learning model that accurately predicts customer churn. By identifying at-risk customers, businesses can take proactive measures to enhance customer retention and improve overall satisfaction.
+    """)
+
+    st.header("🛠 Technological Stack")
+    st.write("""
+    The application is built using the following technologies:
+    - **Python**: The primary programming language used for development.
+    - **Machine Learning**: Algorithms to analyze customer data and predict churn.
+    - **MLOps**: Practices for deploying and maintaining machine learning models.
+    - **ZenML**: A tool to create reproducible ML pipelines.
+    - **MLflow**: For tracking experiments and managing model lifecycle.
+    - **Streamlit**: A user-friendly UI framework for creating interactive web applications.
+    - **FastAPI**: Back-end frameworks to build APIs for model interactions.
+    - **Evidently Ai** : A tool for model monitering and data drift detection
+    """)
+
+
+    st.header(" 📝 Overview")
+    st.write("""
+    This design document outlines the development of a web application for predicting customer churn using a dataset that includes customer Usage Frequency, Tenure  and historical behaviors. The application will allow users to input customer data manually  and receive predictions on churn likelihood and suggested retention strategies.
+    """)
+
+
+    st.header(" 💪 Motivation")
+    st.write("""
+    Understanding and addressing customer churn can significantly enhance customer loyalty and reduce marketing costs associated with acquiring new customers. This application provides insights that help businesses to implement effective retention strategies.
+    """)
+
+
+    st.header(" 📈 Success Metrics")
+    st.write("""
+    The project's success will be measured using the following metrics:
+    - Precision, Recall, and F1 Score of the churn prediction model.
+    - User engagement and satisfaction with the application interface.
+    - Reduction in customer churn rates observed post-implementation.
+    """)
+
+    
+    st.header(" ✍ Requirements & Constraints")
+    st.subheader(" ⚙️ Functional Requirements")
+    st.write("""
+    - Users can input customer data to receive churn predictions.
+    - Users can view performance metrics of the machine learning models.
+    - Users can visualize customer behavior data to derive insights.
+    """)
+
+    st.subheader(" 👨🏻‍💻 Non-Functional Requirements")
+    st.write("""
+    - The model should demonstrate high accuracy in predictions.
+    - The application should be responsive and user-friendly.
+    - User data must be handled securely.
+    """)
+
+    st.subheader("✅️ Constraints")
+    st.write("""
+    - The application must be built using FastAPI and Streamlit, with deployment on Docker and streamlit.
+    """)
+
+    st.header(" 🔄 Methodology")
+    st.write("""
+    - **Problem Statement**: Develop a model to predict customer churn based on various features.
+    - **Data**: Utilize a dataset containing customer-related features such as demographics and service usage.
+    - **Techniques**: Employ data preprocessing, feature engineering, model selection, training, and evaluation.
+    """)
+
+   
+    st.header(" 🏛️ Architecture")
+    st.write("""
+    The architecture of the web application consists of:
+    - A **frontend** built using Streamlit for user interaction.
+    - A **backend** server implemented with FastAPI for handling requests and serving predictions.
+    - A **machine learning model** for churn prediction.
+    - Utilization of **Docker** for containerization.
+
+    """)
+    st.header(" 🖇️ Pipeline")
+    st.image("assets/Pipeline.png", caption="Pipeline", use_column_width=True)
+
+if __name__ == "__main__":
+    home_page()

frontend/main.py

@@ -0,0 +1,31 @@
+import streamlit as st
+import pandas as pd
+from streamlit_option_menu import option_menu
+from about import about_me
+from project import project_ui
+from home import home_page
+from EDA import eda
+from model import metrics_ui
+
+# Sidebar for navigation
+with st.sidebar:
+    selected = option_menu(
+        menu_title="Main Menu",
+        options=["Home", "Project", "EDA", "Model","About Me"],
+        icons=["house", "app-indicator", "bar-chart","person-video" ,"person-video3"],
+        menu_icon="cast",
+        default_index=1,
+    )
+if selected == "Project":
+    project_ui()
+if selected == "Home":
+    home_page()
+
+if selected == "EDA":
+    eda()
+
+if selected == "Model":
+   metrics_ui()
+
+if selected == "About Me":
+    about_me()

frontend/make_prediction.py

@@ -0,0 +1,31 @@
+import requests
+import streamlit as st
+
+
+# Helper function to send data to FastAPI for prediction
+def get_prediction(input_data):
+    """
+    Sends the input data to the FastAPI backend to get a prediction.
+
+    Args:
+        input_data (pd.DataFrame): Input data to send to the FastAPI backend
+
+    Returns:
+        dict or None: The JSON response from the FastAPI backend, or None if the request failed
+    """
+
+
+    url = "http://127.0.0.1:8001/predict"  # URL of the FastAPI backend
+    headers = {"Content-Type": "application/json"}
+
+    json_data = {
+        "dataframe_records": input_data.to_dict(orient="records")
+    }
+
+    try:
+        response = requests.post(url, headers=headers, json=json_data)
+        response.raise_for_status()
+        return response.json()  # Return JSON response from FastAPI
+    except requests.exceptions.RequestException as e:
+        st.error(f"Request failed: {e}")
+        return None

frontend/model.py

@@ -0,0 +1,85 @@
+import streamlit as st
+import pandas as pd
+import streamlit.components.v1 as components
+
+
+metrics_path = "assets/model_metrics.csv"
+metrics_df = pd.read_csv(metrics_path)
+
+def metrics_ui():
+    st.image("data:image/jpeg;base64,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",width=500)
+
+    st.title("Model Evaluation Metrics")
+    st.subheader("Performance Metrics of Trained Models")
+
+    
+    st.dataframe(metrics_df)
+
+    best_model_name = metrics_df.loc[metrics_df['F1 Score'].idxmax(), 'Model']
+    st.write(f"Best Model: {best_model_name} with an F1 Score of {metrics_df['F1 Score'].max():.2f}")
+
+    st.header("What is data drift ?")
+    st.write(
+        """
+Data Drift is a name for data change that can affect the Machine Learning model performance. There are different types
+of drift.There can be change in target distribution.
+
+For example you have a model that predicts house price based on the property description (no.of rooms,location,etc.,)
+but there is a change in the market and all properities prices go up.
+
+If you don't detect the drift in the target distribution and don't update the model with new targets then your model will predict too low pricies.
+
+The chnage in the target distribution is so-called **target distribution.**
+
+The next type of drift is **covariate drift**.it is a change in the input data distribution. For example, you have 
+a categorical feature that will start to have new category.
+"""
+    )
+
+
+    st.header("what to do after data drift detection ?")
+    st.write(
+        """
+When data drift is detected that ML model should be updated. There are many ways in which it can be done - all depends on the
+data. The most striaght forward way is to use all avaiable data samples to train a new model. The other approach might be to use just
+a new data samples to train the model.
+
+There might be also approaches with sample weighting - giving higher weight for fresh data samples and lower weights for old samples.
+it depends on the data.
+"""
+    )
+
+    st.header("How to detect data drift ?")
+    st.write("""
+The data drift can be detected in different ways. The simplest approach is to use statistical tests that compare 
+the distribution of the trainig data and live data (production data). If the differnec between two distribution is significantly then a drift occured.
+
+The most popular test are **two-sample, kolmogorov-Smirnov test,Chi square test, jensen-shannon divergence, Wasserstein distance.**
+The alternative approach might be use Machine Learning model to monitar the data quality. There can be also hybrid approaches.
+             """)
+    
+
+    st.subheader("Dataset Drift")
+    html = "frontend/reports/report.html"
+    with open(html,'r') as f:
+        html_data= f.read()
+    
+    st.components.v1.html(html_data,scrolling = True,height=700,width= 800)
+
+
+    st.subheader("Decison Tree Model Report")
+    html = "frontend/reports/model_report_1.html"
+    with open(html,'r') as f:
+        html_data= f.read()
+    
+    st.components.v1.html(html_data,scrolling = True,height=700,width= 800)
+
+    st.subheader("RandomForest Model  Drift")
+    html = "frontend/reports/model_report_2.html"
+    with open(html,'r') as f:
+        html_data= f.read()
+    
+    st.components.v1.html(html_data,scrolling = True,height=700,width= 800)
+
+
+    

frontend/project.py

@@ -0,0 +1,66 @@
+import streamlit as st
+import pandas as pd
+from make_prediction import get_prediction
+import pickle
+
+
+def project_ui():
+    st.image("assets/customer_churn_image.jpg",width=600)
+    st.title("Customer Churn Prediction")
+    
+    
+    age = st.number_input("**Age**", min_value=18, max_value=100, step=1)
+    gender = st.selectbox("**Gender**", options=["Male", "Female"])
+    gender_encoded = 1 if gender == "Male" else 0
+
+    tenure = st.number_input("**Tenure (months)**", min_value=0, step=1)
+    usage_frequency = st.number_input("**Usage Frequency**", min_value=0, step=1)
+    support_calls = st.number_input("**Support Calls**", min_value=0, step=1)
+    payment_delay = st.number_input("**Payment Delay**", min_value=0, step=1)
+
+    subscription_type = st.selectbox("**Subscription Type**", options=["Standard", "Basic", "Premium"])
+    subscription_type_encoded = {"Standard": 2, "Basic": 0, "Premium": 1}[subscription_type]
+
+    contract_length = st.selectbox("**Contract Length**", options=["Annual", "Monthly", "Quarterly"])
+    contract_length_encoded = {"Annual": 0, "Monthly": 1, "Quarterly": 2}[contract_length]
+
+    total_spend = st.number_input("**Total Spend**", min_value=0.0, step=1.0)
+    last_interaction = st.number_input("Last Interaction (days ago)", min_value=0, step=1)
+
+    # Create DataFrame of input data for the prediction
+    input_data = pd.DataFrame({
+        "Age": [age],
+        "Gender": [gender_encoded],
+        "Tenure": [tenure],
+        "Usage Frequency": [usage_frequency],
+        "Support Calls": [support_calls],
+        "Payment Delay": [payment_delay],
+        "Subscription Type": [subscription_type_encoded],
+        "Contract Length": [contract_length_encoded],
+        "Total Spend": [total_spend],
+        "Last Interaction": [last_interaction],
+    })
+
+    
+    if st.button("Predict Churn"):
+        prediction = get_prediction(input_data)
+        
+        
+        if prediction is not None:
+            churn_value = int(prediction['predictions'][0]) 
+            churn_prediction = "Will Churn" if churn_value == 1 else "Won't Churn"
+            st.success(f"Prediction: {churn_prediction}")
+        else:
+            st.write("Prediction request failed. We are using local model ")
+            with open("backend/artifacts/XGBoost.pkl","rb") as file:
+                model= pickle.load(file)
+            result = model.predict(input_data)
+            churn_prediction = "Will Churn" if result ==1 else "Won't Churn"
+            st.success(f"Prediction : {churn_prediction}")
+
+
+if __name__ == "__main__":
+    project_ui()
+
+
+