Upload 7 files

models/kmeans_model_main.pkl

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

models/label_encoders.pkl

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

models/neural_network_model_final.pth

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

models/scaler.pkl

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

new_app.py

@@ -0,0 +1,105 @@
+import gradio as gr
+import pandas as pd
+from utilfuncs import (
+    load_kmeans_model,
+    load_churn_model,
+    encode_and_scale,
+    get_cluster,
+    get_churn_label,
+    load_encoder,
+    load_scaler,
+    create_tsne_plot
+)
+
+def app():
+    kmeans_model = load_kmeans_model('models/kmeans_model_main.pkl')
+    churn_model = load_churn_model('models/neural_network_model_final.pth')
+    encoders = load_encoder('models/label_encoders.pkl')
+    scaler = load_scaler('models/scaler.pkl')
+
+    def predict(age, gender, location, subscription_length, monthly_bill, avg_internet_usage, num_tickets, avg_talktime, social_class, subscription_type, base_charge):
+        data = {
+            'Age': [age],
+            'Gender': [gender],
+            'Location': [location],
+            'Subscription_Length_Months': [subscription_length],
+            'Monthly_Bill': [monthly_bill],
+            'Average_Internet_Usage': [avg_internet_usage],
+            'No_of_Tickets': [num_tickets],
+            'Average_Talktime_Usage': [avg_talktime],
+            'Social_Class': [social_class],
+            'Subscription_Type': [subscription_type],
+            'Base_Charge': [base_charge]
+        }
+        df = pd.DataFrame(data)
+        scaled_df = encode_and_scale(df, encoders, scaler)
+        group = get_cluster(scaled_df, kmeans_model)
+        predicted_group_text = group[0]
+        churn_label = get_churn_label(scaled_df, churn_model)
+        predicted_churn_text = 'Yes' if churn_label[0][0] == 1 else 'No'
+        return predicted_group_text, predicted_churn_text
+
+    def process_csv(file):
+        df = pd.read_csv(file)
+
+        required_columns = ['CustomerID', 'Name', 'Age', 'Gender', 'Location',
+                            'Subscription_Length_Months', 'Monthly_Bill', 'Average_Internet_Usage',
+                            'No_of_Tickets', 'Average_Talktime_Usage', 'Social_Class',
+                            'Subscription_Type', 'Base_Charge']
+        
+        if not all(col in df.columns for col in required_columns):
+            return "Error: The CSV file must have the following columns: " + ", ".join(required_columns)
+        
+        df = df.drop(columns=['CustomerID', 'Name'])
+
+        scaled_df = encode_and_scale(df, encoders, scaler)
+        groups = get_cluster(scaled_df, kmeans_model)
+        churn_labels = get_churn_label(scaled_df, churn_model)
+
+        tsne_plot = create_tsne_plot(scaled_df, groups)
+
+        churn_percentage = (churn_labels[:, 0] == 1).float().mean() * 100
+
+        return tsne_plot, f"Predicted Churn Percentage: {churn_percentage:.2f}%"
+
+    with gr.Blocks() as app:
+        with gr.Tab("Churn Prediction"):
+            with gr.Group():
+                gr.Markdown("## Churn Prediction App")
+                age = gr.Slider(label="Age", minimum=18, maximum=100, step=1, value=30)
+                gender = gr.Dropdown(label="Gender", choices=["Male", "Female"], value="Male")
+                location = gr.Dropdown(label="Location", choices=["Urban", "Rural", "Suburban"], value="Urban")
+                subscription_length = gr.Slider(label="Subscription Length (Months)", minimum=1, maximum=60, step=1, value=12)
+                monthly_bill = gr.Slider(label="Monthly Bill", minimum=10, maximum=1000, step=1, value=50)
+                avg_internet_usage = gr.Slider(label="Average Internet Usage", minimum=1, maximum=200, step=1, value=50)
+                num_tickets = gr.Slider(label="Number of Tickets", minimum=0, maximum=20, step=1, value=2)
+                avg_talktime = gr.Slider(label="Average Talktime Usage", minimum=1, maximum=200, step=1, value=50)
+                social_class = gr.Slider(label="Social Class", minimum=1, maximum=3, step=1, value=1)
+                subscription_type = gr.Dropdown(label="Subscription Type", choices=["A", "B", "C", "D", "E"], value="B")
+                base_charge = gr.Slider(label="Base Charge", minimum=10, maximum=500, step=1, value=30)
+
+            with gr.Group():
+                gr.Markdown("## Results")
+                predicted_group = gr.Text(label="Predicted Group")
+                predicted_churn = gr.Text(label="Predicted Churn")
+
+            predict_button = gr.Button("Predict")
+            predict_button.click(predict, inputs=[age, gender, location, subscription_length, monthly_bill, avg_internet_usage, num_tickets, avg_talktime, social_class, subscription_type, base_charge], outputs=[predicted_group, predicted_churn])
+
+        with gr.Tab("Upload CSV"):
+            with gr.Group():
+                gr.Markdown("## Upload CSV for Analysis")
+                csv_file = gr.File(label="Upload CSV")
+                process_button = gr.Button("Process CSV")
+
+            with gr.Group():
+                gr.Markdown("## Results")
+                tsne_plot = gr.Image(label="t-SNE Plot")
+                churn_percentage = gr.Text(label="Predicted Churn Percentage")
+
+            process_button.click(process_csv, inputs=[csv_file], outputs=[tsne_plot, churn_percentage])
+
+    app.launch()
+
+if __name__ == "__main__":
+    app()

requirements.txt

@@ -0,0 +1,9 @@
+torch
+joblib
+pandas
+numpy
+scikit-learn
+matplotlib
+seaborn
+Pillow
+gradio

utilfuncs.py

@@ -0,0 +1,101 @@
+import torch
+import torch.nn as nn
+import joblib
+import pandas as pd
+from sklearn.manifold import TSNE
+import matplotlib.pyplot as plt
+import seaborn as sns
+import io
+import numpy as np
+from PIL import Image
+
+class FixedNeuronsNetwork(nn.Module):
+    def __init__(self, num_features, num_classes, num_hidden_layers, hidden_neurons, layer_activation=nn.ReLU, final_activation=nn.Sigmoid):
+        super(FixedNeuronsNetwork, self).__init__()
+        
+        layers = []
+        
+        layers.append(nn.Linear(num_features, hidden_neurons))
+        layers.append(layer_activation())
+        
+        for _ in range(num_hidden_layers - 1):
+            layers.append(nn.Linear(hidden_neurons, hidden_neurons))
+            layers.append(layer_activation())
+        
+        layers.append(nn.Linear(hidden_neurons, num_classes))
+        
+        self.final_activation = final_activation()
+        
+        self.network = nn.Sequential(*layers)
+        
+    def forward(self, x):
+        x = self.network(x)
+        output = self.final_activation(x)
+        return output
+    
+def load_kmeans_model(model_path):
+    kmeans_loaded = joblib.load('kmeans_model_main.pkl')
+    return kmeans_loaded
+
+def load_churn_model(model_path):
+    model = FixedNeuronsNetwork(num_features=11,num_classes=1,num_hidden_layers=3,hidden_neurons=64).to('cpu')
+    model.load_state_dict(torch.load(model_path))
+
+    return model
+
+def load_encoder(model_path):
+    label_encoders = joblib.load(model_path)
+    return label_encoders
+
+def load_scaler(model_path):
+    scaler = joblib.load(model_path)
+    return scaler
+
+def encode_and_scale(new_sample_df, encoders, scaler):
+
+    numerical_cols = ['Age', 'Subscription_Length_Months', 'Monthly_Bill','Average_Internet_Usage', 'No_of_Tickets', 'Average_Talktime_Usage','Social_Class', 'Base_Charge']
+    new_sample_df[numerical_cols] = scaler.transform(new_sample_df[numerical_cols])
+
+    for col, le in encoders.items():
+        new_sample_df[col] = le.transform(new_sample_df[col])
+
+    return new_sample_df
+
+def get_cluster(sample, kmeans_loaded):
+    group = kmeans_loaded.predict(sample)
+
+    return group
+
+def get_churn_label(sample, model):
+    sample_tensor = torch.tensor(sample.values, dtype=torch.float32)
+    model.eval()
+    with torch.no_grad():
+        predictions = model(sample_tensor)
+        predictions = (predictions > 0.5).float()
+
+    return predictions
+
+def create_tsne_plot(df, clusters):
+
+    tsne = TSNE(n_components=2, random_state=42)
+    tsne_results = tsne.fit_transform(df)
+
+    df_tsne = pd.DataFrame(tsne_results, columns=['TSNE1', 'TSNE2'])
+    df_tsne['Cluster'] = clusters
+
+    plt.figure(figsize=(10, 8))
+    sns.scatterplot(
+        x='TSNE1', y='TSNE2',
+        hue='Cluster',
+        palette=sns.color_palette('hsv', len(set(clusters))),
+        data=df_tsne,
+        legend='full'
+    )
+    plt.title('t-SNE Visualization of K Means Clustering')
+    
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    buf.seek(0)
+    plot_image = np.asarray(Image.open(buf))
+
+    return plot_image