Added

Dockerfile

@@ -1,14 +1,15 @@
-# read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
+FROM python:3.8.12-slim
 
-FROM python:3.9
+RUN /usr/local/bin/python -m pip install --upgrade pip
 
-WORKDIR /code
+WORKDIR /app
 
-COPY ./requirements.txt /code/requirements.txt
+COPY . .
 
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+RUN pip install -r requirements.txt
 
-COPY . .
+EXPOSE 8501
+
+ENTRYPOINT ["streamlit", "run"]
 
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["stream_app.py"]

Pipfile

@@ -0,0 +1,18 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+numpy = "*"
+pandas = "*"
+streamlit = "==0.87"
+scikit-learn = "==0.24.2"
+Pillow = "*"
+click = "<8"
+protobuf = "==3.20.1"
+
+[dev-packages]
+
+[requires]
+python_version = "3.8"

requirements.txt

@@ -0,0 +1,2 @@
+scikit-learn==0.24.2
+streamlit

stream_app.py

@@ -0,0 +1,84 @@
+import pickle
+import streamlit as st
+import pandas as pd
+from PIL import Image
+model_file = 'model_C=1.0.bin'
+
+with open(model_file, 'rb') as f_in:
+    dv, model = pickle.load(f_in)
+
+
+def main():
+
+	image = Image.open('images/icone.png')
+	image2 = Image.open('images/image.png')
+	st.image(image,use_column_width=False)
+	add_selectbox = st.sidebar.selectbox(
+	"How would you like to predict?",
+	("Online", "Batch"))
+	st.sidebar.info('This app is created to predict Customer Churn')
+	st.sidebar.image(image2)
+	st.title("Predicting Customer Churn")
+	if add_selectbox == 'Online':
+		gender = st.selectbox('Gender:', ['male', 'female'])
+		seniorcitizen= st.selectbox(' Customer is a senior citizen:', [0, 1])
+		partner= st.selectbox(' Customer has a partner:', ['yes', 'no'])
+		dependents = st.selectbox(' Customer has  dependents:', ['yes', 'no'])
+		phoneservice = st.selectbox(' Customer has phoneservice:', ['yes', 'no'])
+		multiplelines = st.selectbox(' Customer has multiplelines:', ['yes', 'no', 'no_phone_service'])
+		internetservice= st.selectbox(' Customer has internetservice:', ['dsl', 'no', 'fiber_optic'])
+		onlinesecurity= st.selectbox(' Customer has onlinesecurity:', ['yes', 'no', 'no_internet_service'])
+		onlinebackup = st.selectbox(' Customer has onlinebackup:', ['yes', 'no', 'no_internet_service'])
+		deviceprotection = st.selectbox(' Customer has deviceprotection:', ['yes', 'no', 'no_internet_service'])
+		techsupport = st.selectbox(' Customer has techsupport:', ['yes', 'no', 'no_internet_service'])
+		streamingtv = st.selectbox(' Customer has streamingtv:', ['yes', 'no', 'no_internet_service'])
+		streamingmovies = st.selectbox(' Customer has streamingmovies:', ['yes', 'no', 'no_internet_service'])
+		contract= st.selectbox(' Customer has a contract:', ['month-to-month', 'one_year', 'two_year'])
+		paperlessbilling = st.selectbox(' Customer has a paperlessbilling:', ['yes', 'no'])
+		paymentmethod= st.selectbox('Payment Option:', ['bank_transfer_(automatic)', 'credit_card_(automatic)', 'electronic_check' ,'mailed_check'])
+		tenure = st.number_input('Number of months the customer has been with the current telco provider :', min_value=0, max_value=240, value=0)
+		monthlycharges= st.number_input('Monthly charges :', min_value=0, max_value=240, value=0)
+		totalcharges = tenure*monthlycharges
+		output= ""
+		output_prob = ""
+		input_dict={
+				"gender":gender ,
+				"seniorcitizen": seniorcitizen,
+				"partner": partner,
+				"dependents": dependents,
+				"phoneservice": phoneservice,
+				"multiplelines": multiplelines,
+				"internetservice": internetservice,
+				"onlinesecurity": onlinesecurity,
+				"onlinebackup": onlinebackup,
+				"deviceprotection": deviceprotection,
+				"techsupport": techsupport,
+				"streamingtv": streamingtv,
+				"streamingmovies": streamingmovies,
+				"contract": contract,
+				"paperlessbilling": paperlessbilling,
+				"paymentmethod": paymentmethod,
+				"tenure": tenure,
+				"monthlycharges": monthlycharges,
+				"totalcharges": totalcharges
+			}
+
+		if st.button("Predict"):
+			X = dv.transform([input_dict])
+			y_pred = model.predict_proba(X)[0, 1]
+			churn = y_pred >= 0.5
+			output_prob = float(y_pred)
+			output = bool(churn)
+		st.success('Churn: {0}, Risk Score: {1}'.format(output, output_prob))
+	if add_selectbox == 'Batch':
+		file_upload = st.file_uploader("Upload csv file for predictions", type=["csv"])
+		if file_upload is not None:
+			data = pd.read_csv(file_upload)
+			X = dv.transform([data])
+			y_pred = model.predict_proba(X)[0, 1]
+			churn = y_pred >= 0.5
+			churn = bool(churn)
+			st.write(churn)
+
+if __name__ == '__main__':
+	main()

train.py

@@ -0,0 +1,131 @@
+
+# coding: utf-8
+
+import pickle
+
+import pandas as pd
+import numpy as np
+
+from sklearn.model_selection import train_test_split
+from sklearn.model_selection import KFold
+
+from sklearn.feature_extraction import DictVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import roc_auc_score
+
+# parameters
+
+C = 1.0
+n_splits = 5
+output_file = f'model_C={C}.bin'
+
+# data preparation
+
+df = pd.read_csv('WA_Fn-UseC_-Telco-Customer-Churn.csv')
+
+df.columns = df.columns.str.lower().str.replace(' ', '_')
+
+categorical_columns = list(df.dtypes[df.dtypes == 'object'].index)
+
+for c in categorical_columns:
+    df[c] = df[c].str.lower().str.replace(' ', '_')
+
+df.totalcharges = pd.to_numeric(df.totalcharges, errors='coerce')
+df.totalcharges = df.totalcharges.fillna(0)
+
+df.churn = (df.churn == 'yes').astype(int)
+
+df_full_train, df_test = train_test_split(df, test_size=0.2, random_state=1)
+
+numerical = ['tenure', 'monthlycharges', 'totalcharges']
+
+categorical = [
+    'gender',
+    'seniorcitizen',
+    'partner',
+    'dependents',
+    'phoneservice',
+    'multiplelines',
+    'internetservice',
+    'onlinesecurity',
+    'onlinebackup',
+    'deviceprotection',
+    'techsupport',
+    'streamingtv',
+    'streamingmovies',
+    'contract',
+    'paperlessbilling',
+    'paymentmethod',
+]
+
+
+# training
+
+def train(df_train, y_train, C=1.0):
+    dicts = df_train[categorical + numerical].to_dict(orient='records')
+
+    dv = DictVectorizer(sparse=False)
+    X_train = dv.fit_transform(dicts)
+
+    model = LogisticRegression(C=C, max_iter=1000)
+    model.fit(X_train, y_train)
+
+    return dv, model
+
+
+def predict(df, dv, model):
+    dicts = df[categorical + numerical].to_dict(orient='records')
+
+    X = dv.transform(dicts)
+    y_pred = model.predict_proba(X)[:, 1]
+
+    return y_pred
+
+
+# validation
+
+print(f'doing validation with C={C}')
+
+kfold = KFold(n_splits=n_splits, shuffle=True, random_state=1)
+
+scores = []
+
+fold = 0
+
+for train_idx, val_idx in kfold.split(df_full_train):
+    df_train = df_full_train.iloc[train_idx]
+    df_val = df_full_train.iloc[val_idx]
+
+    y_train = df_train.churn.values
+    y_val = df_val.churn.values
+
+    dv, model = train(df_train, y_train, C=C)
+    y_pred = predict(df_val, dv, model)
+
+    auc = roc_auc_score(y_val, y_pred)
+    scores.append(auc)
+
+    print(f'auc on fold {fold} is {auc}')
+    fold = fold + 1
+
+print('validation results:')
+print('C=%s %.3f +- %.3f' % (C, np.mean(scores), np.std(scores)))
+
+# training the final model
+
+print('training the final model')
+
+dv, model = train(df_full_train, df_full_train.churn.values, C=1.0)
+y_pred = predict(df_test, dv, model)
+
+y_test = df_test.churn.values
+auc = roc_auc_score(y_test, y_pred)
+
+print(f'auc={auc}')
+
+# Save the model
+
+with open(output_file, 'wb') as f_out:
+    pickle.dump((dv, model), f_out)
+
+print(f'the model is saved to {output_file}')