|
|
import marimo |
|
|
|
|
|
__generated_with = "0.11.20" |
|
|
app = marimo.App(width="medium") |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _(mo): |
|
|
mo.md(r"""# Customer Churn Analysis""") |
|
|
return |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _(): |
|
|
import marimo as mo |
|
|
import polars as pl |
|
|
import altair as alt |
|
|
return alt, mo, pl |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _(pl): |
|
|
df = pl.read_csv( |
|
|
"hf://datasets/louiecerv/customer_churn/customer_churn_data.csv" |
|
|
) |
|
|
df.describe() |
|
|
return (df,) |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _(df): |
|
|
df.head() |
|
|
return |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _(df, pl): |
|
|
from sklearn.preprocessing import ( |
|
|
RobustScaler, |
|
|
OneHotEncoder, |
|
|
MinMaxScaler, |
|
|
OrdinalEncoder, |
|
|
) |
|
|
from sklearn.pipeline import make_pipeline |
|
|
from sklearn.compose import make_column_transformer |
|
|
from sklearn.linear_model import ( |
|
|
LogisticRegression, |
|
|
BayesianRidge, |
|
|
RidgeClassifier, |
|
|
SGDClassifier, |
|
|
) |
|
|
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis |
|
|
from sklearn.naive_bayes import BernoulliNB |
|
|
from sklearn.svm import SVC |
|
|
from sklearn.tree import DecisionTreeClassifier |
|
|
from sklearn.neighbors import KNeighborsClassifier |
|
|
from sklearn.ensemble import ( |
|
|
VotingClassifier, |
|
|
BaggingClassifier, |
|
|
GradientBoostingClassifier, |
|
|
RandomForestClassifier, |
|
|
) |
|
|
from sklearn.feature_selection import RFE, RFECV, SequentialFeatureSelector |
|
|
from sklearn.model_selection import train_test_split |
|
|
|
|
|
num_features = ["tenure", "monthly_charges", "total_charges"] |
|
|
cat_features = ["contract_One Two year", "internet_service_Fiber No"] |
|
|
random_state = 33 |
|
|
|
|
|
df2 = df.with_columns( |
|
|
(pl.col("contract_One year") + "_" + pl.col("contract_Two year")).alias( |
|
|
"contract_One Two year" |
|
|
), |
|
|
( |
|
|
pl.col("internet_service_Fiber optic") |
|
|
+ "_" |
|
|
+ pl.col("internet_service_No") |
|
|
).alias("internet_service_Fiber No"), |
|
|
) |
|
|
|
|
|
X, y = df2.select(num_features + cat_features), df2.select(["churn"]) |
|
|
|
|
|
X_train, X_test, y_train, y_test = train_test_split( |
|
|
X, y, test_size=0.32, random_state=random_state |
|
|
) |
|
|
|
|
|
preprocessor = make_column_transformer( |
|
|
(OneHotEncoder(), cat_features), |
|
|
(MinMaxScaler(), num_features), |
|
|
) |
|
|
|
|
|
knc = KNeighborsClassifier(algorithm="ball_tree") |
|
|
dtree = DecisionTreeClassifier(criterion="entropy", random_state=random_state) |
|
|
rfc = RandomForestClassifier( |
|
|
criterion="entropy", max_features=0.3, random_state=random_state |
|
|
) |
|
|
gbc = GradientBoostingClassifier(random_state=random_state) |
|
|
bag = BaggingClassifier( |
|
|
KNeighborsClassifier(), |
|
|
max_samples=0.8, |
|
|
max_features=0.8, |
|
|
random_state=random_state, |
|
|
) |
|
|
|
|
|
log_pipe = make_pipeline( |
|
|
preprocessor, LogisticRegression(max_iter=10000, random_state=random_state) |
|
|
) |
|
|
bridge_pipe = make_pipeline(preprocessor, BayesianRidge(max_iter=10000)) |
|
|
ridge_pipe = make_pipeline( |
|
|
preprocessor, RidgeClassifier(max_iter=10000, random_state=random_state) |
|
|
) |
|
|
sgd_pipe = make_pipeline( |
|
|
preprocessor, |
|
|
SGDClassifier( |
|
|
loss="hinge", penalty="l2", max_iter=10000, random_state=random_state |
|
|
), |
|
|
) |
|
|
lda_pipe = make_pipeline(preprocessor, QuadraticDiscriminantAnalysis()) |
|
|
bnb_pipe = make_pipeline(preprocessor, BernoulliNB()) |
|
|
svc_pipe = make_pipeline( |
|
|
preprocessor, SVC(kernel="rbf", max_iter=10000, random_state=random_state) |
|
|
) |
|
|
dtree_pipe = make_pipeline(preprocessor, dtree) |
|
|
rfc_pipe = make_pipeline(preprocessor, rfc) |
|
|
knc_pipe = make_pipeline(preprocessor, knc) |
|
|
gbc_pipe = make_pipeline(preprocessor, gbc) |
|
|
vot_pipe = make_pipeline( |
|
|
preprocessor, |
|
|
VotingClassifier( |
|
|
estimators=[ |
|
|
("qda", QuadraticDiscriminantAnalysis()), |
|
|
("dtree", dtree), |
|
|
], |
|
|
voting="soft", |
|
|
weights=[5, 2], |
|
|
), |
|
|
) |
|
|
bag_pipe = make_pipeline(preprocessor, bag) |
|
|
|
|
|
log_pred = log_pipe.fit(X_train, y_train).predict(X_test) |
|
|
bridge_pred = bridge_pipe.fit(X_train, y_train).predict(X_test) |
|
|
ridge_pred = ridge_pipe.fit(X_train, y_train).predict(X_test) |
|
|
sgd_pred = sgd_pipe.fit(X_train, y_train).predict(X_test) |
|
|
lda_pred = lda_pipe.fit(X_train, y_train).predict(X_test) |
|
|
bnb_pred = bnb_pipe.fit(X_train, y_train).predict(X_test) |
|
|
svc_pred = svc_pipe.fit(X_train, y_train).predict(X_test) |
|
|
dtree_pred = dtree_pipe.fit(X_train, y_train).predict(X_test) |
|
|
rfc_pred = dtree_pipe.fit(X_train, y_train).predict(X_test) |
|
|
knc_pred = knc_pipe.fit(X_train, y_train).predict(X_test) |
|
|
gbc_pred = gbc_pipe.fit(X_train, y_train).predict(X_test) |
|
|
vot_pred = vot_pipe.fit(X_train, y_train).predict(X_test) |
|
|
bag_pred = bag_pipe.fit(X_train, y_train).predict(X_test) |
|
|
return ( |
|
|
BaggingClassifier, |
|
|
BayesianRidge, |
|
|
BernoulliNB, |
|
|
DecisionTreeClassifier, |
|
|
GradientBoostingClassifier, |
|
|
KNeighborsClassifier, |
|
|
LogisticRegression, |
|
|
MinMaxScaler, |
|
|
OneHotEncoder, |
|
|
OrdinalEncoder, |
|
|
QuadraticDiscriminantAnalysis, |
|
|
RFE, |
|
|
RFECV, |
|
|
RandomForestClassifier, |
|
|
RidgeClassifier, |
|
|
RobustScaler, |
|
|
SGDClassifier, |
|
|
SVC, |
|
|
SequentialFeatureSelector, |
|
|
VotingClassifier, |
|
|
X, |
|
|
X_test, |
|
|
X_train, |
|
|
bag, |
|
|
bag_pipe, |
|
|
bag_pred, |
|
|
bnb_pipe, |
|
|
bnb_pred, |
|
|
bridge_pipe, |
|
|
bridge_pred, |
|
|
cat_features, |
|
|
df2, |
|
|
dtree, |
|
|
dtree_pipe, |
|
|
dtree_pred, |
|
|
gbc, |
|
|
gbc_pipe, |
|
|
gbc_pred, |
|
|
knc, |
|
|
knc_pipe, |
|
|
knc_pred, |
|
|
lda_pipe, |
|
|
lda_pred, |
|
|
log_pipe, |
|
|
log_pred, |
|
|
make_column_transformer, |
|
|
make_pipeline, |
|
|
num_features, |
|
|
preprocessor, |
|
|
random_state, |
|
|
rfc, |
|
|
rfc_pipe, |
|
|
rfc_pred, |
|
|
ridge_pipe, |
|
|
ridge_pred, |
|
|
sgd_pipe, |
|
|
sgd_pred, |
|
|
svc_pipe, |
|
|
svc_pred, |
|
|
train_test_split, |
|
|
vot_pipe, |
|
|
vot_pred, |
|
|
y, |
|
|
y_test, |
|
|
y_train, |
|
|
) |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _( |
|
|
bag_pred, |
|
|
bnb_pred, |
|
|
bridge_pred, |
|
|
dtree_pred, |
|
|
gbc_pred, |
|
|
knc_pred, |
|
|
lda_pred, |
|
|
log_pred, |
|
|
mo, |
|
|
rfc_pred, |
|
|
ridge_pred, |
|
|
sgd_pred, |
|
|
svc_pred, |
|
|
vot_pred, |
|
|
y_test, |
|
|
): |
|
|
from sklearn.metrics import ( |
|
|
accuracy_score, |
|
|
precision_score, |
|
|
f1_score, |
|
|
recall_score, |
|
|
roc_auc_score, |
|
|
log_loss, |
|
|
mean_squared_error, |
|
|
root_mean_squared_error, |
|
|
mean_absolute_error, |
|
|
r2_score, |
|
|
explained_variance_score, |
|
|
) |
|
|
|
|
|
mo.md(f""" |
|
|
# Model Metrics |
|
|
|
|
|
## Logistic Regression |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, log_pred)} |
|
|
- Precision: {precision_score(y_test, log_pred)} |
|
|
- Recall: {recall_score(y_test, log_pred)} |
|
|
- F1: {f1_score(y_test, log_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, log_pred)} |
|
|
- Log Loss: {log_loss(y_test, log_pred)} |
|
|
|
|
|
## Ridge Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, ridge_pred)} |
|
|
- Precision: {precision_score(y_test, ridge_pred)} |
|
|
- Recall: {recall_score(y_test, ridge_pred)} |
|
|
- F1: {f1_score(y_test, ridge_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, ridge_pred)} |
|
|
- Log Loss: {log_loss(y_test, ridge_pred)} |
|
|
|
|
|
## SGD Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, sgd_pred)} |
|
|
- Precision: {precision_score(y_test, sgd_pred)} |
|
|
- Recall: {recall_score(y_test, sgd_pred)} |
|
|
- F1: {f1_score(y_test, sgd_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, sgd_pred)} |
|
|
- Log Loss: {log_loss(y_test, sgd_pred)} |
|
|
|
|
|
## Bayesian Ridge Regression |
|
|
|
|
|
- Mean Squared Error: {mean_squared_error(y_test, bridge_pred)} |
|
|
- Root Mean Squared Error: {root_mean_squared_error(y_test, bridge_pred)} |
|
|
- Mean Absolute Error: {mean_absolute_error(y_test, bridge_pred)} |
|
|
- R^2: {r2_score(y_test, bridge_pred)} |
|
|
- Explained Variance: {explained_variance_score(y_test, bridge_pred)} |
|
|
|
|
|
## Quadratic Discriminant Analysis |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, lda_pred)} |
|
|
- Precision: {precision_score(y_test, lda_pred)} |
|
|
- Recall: {recall_score(y_test, lda_pred)} |
|
|
- F1: {f1_score(y_test, lda_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, lda_pred)} |
|
|
- Log Loss: {log_loss(y_test, lda_pred)} |
|
|
|
|
|
## Bernoulli Naive Bayes |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, bnb_pred)} |
|
|
- Precision: {precision_score(y_test, bnb_pred)} |
|
|
- Recall: {recall_score(y_test, bnb_pred)} |
|
|
- F1: {f1_score(y_test, bnb_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, bnb_pred)} |
|
|
- Log Loss: {log_loss(y_test, bnb_pred)} |
|
|
|
|
|
## C-Support Vector Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, svc_pred)} |
|
|
- Precision: {precision_score(y_test, svc_pred)} |
|
|
- Recall: {recall_score(y_test, svc_pred)} |
|
|
- F1: {f1_score(y_test, svc_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, svc_pred)} |
|
|
- Log Loss: {log_loss(y_test, svc_pred)} |
|
|
|
|
|
## Decision Tree Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, dtree_pred)} |
|
|
- Precision: {precision_score(y_test, dtree_pred)} |
|
|
- Recall: {recall_score(y_test, dtree_pred)} |
|
|
- F1: {f1_score(y_test, dtree_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, dtree_pred)} |
|
|
- Log Loss: {log_loss(y_test, dtree_pred)} |
|
|
|
|
|
## Random Forest Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, rfc_pred)} |
|
|
- Precision: {precision_score(y_test, rfc_pred)} |
|
|
- Recall: {recall_score(y_test, rfc_pred)} |
|
|
- F1: {f1_score(y_test, rfc_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, rfc_pred)} |
|
|
- Log Loss: {log_loss(y_test, rfc_pred)} |
|
|
|
|
|
## K Neighbors Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, knc_pred)} |
|
|
- Precision: {precision_score(y_test, knc_pred)} |
|
|
- Recall: {recall_score(y_test, knc_pred)} |
|
|
- F1: {f1_score(y_test, knc_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, knc_pred)} |
|
|
- Log Loss: {log_loss(y_test, knc_pred)} |
|
|
|
|
|
## Gradient Boosting Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, gbc_pred)} |
|
|
- Precision: {precision_score(y_test, gbc_pred)} |
|
|
- Recall: {recall_score(y_test, gbc_pred)} |
|
|
- F1: {f1_score(y_test, gbc_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, gbc_pred)} |
|
|
- Log Loss: {log_loss(y_test, gbc_pred)} |
|
|
|
|
|
## Voting Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, vot_pred)} |
|
|
- Precision: {precision_score(y_test, vot_pred)} |
|
|
- Recall: {recall_score(y_test, vot_pred)} |
|
|
- F1: {f1_score(y_test, vot_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, vot_pred)} |
|
|
- Log Loss: {log_loss(y_test, vot_pred)} |
|
|
|
|
|
## Bagging Classifier |
|
|
|
|
|
- Accuracy: {accuracy_score(y_test, bag_pred)} |
|
|
- Precision: {precision_score(y_test, bag_pred)} |
|
|
- Recall: {recall_score(y_test, bag_pred)} |
|
|
- F1: {f1_score(y_test, bag_pred)} |
|
|
- ROC-AUC: {roc_auc_score(y_test, bag_pred)} |
|
|
- Log Loss: {log_loss(y_test, bag_pred)} |
|
|
|
|
|
{ |
|
|
mo.callout( |
|
|
"From the metrics, the Quadratic Discriminant Analysis and the Decision Tree Classifier perform the best, thus, they were chosen for the Voting Classifier", |
|
|
kind="info", |
|
|
) |
|
|
} |
|
|
""") |
|
|
return ( |
|
|
accuracy_score, |
|
|
explained_variance_score, |
|
|
f1_score, |
|
|
log_loss, |
|
|
mean_absolute_error, |
|
|
mean_squared_error, |
|
|
precision_score, |
|
|
r2_score, |
|
|
recall_score, |
|
|
roc_auc_score, |
|
|
root_mean_squared_error, |
|
|
) |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _(mo): |
|
|
user_inputs = mo.ui.dictionary( |
|
|
{ |
|
|
"tenure": mo.ui.number(label="Tenure", start=1, stop=72, step=1), |
|
|
"monthly_charges": mo.ui.number( |
|
|
label="Monthly Charges", start=20, stop=120, step=1 |
|
|
), |
|
|
"total_charges": mo.ui.number( |
|
|
label="Total Charges", start=20, stop=8000, step=1 |
|
|
), |
|
|
"contract": mo.ui.dropdown( |
|
|
label="Contract (Year)", options=["None", "One", "Two"] |
|
|
), |
|
|
"service": mo.ui.dropdown( |
|
|
label="Service", options=["None", "Basic", "Fiber Optic"] |
|
|
), |
|
|
} |
|
|
) |
|
|
|
|
|
mo.vstack(user_inputs.values()) |
|
|
return (user_inputs,) |
|
|
|
|
|
|
|
|
@app.cell |
|
|
def _(mo, pl, user_inputs, vot_pipe): |
|
|
contract = None |
|
|
service = None |
|
|
|
|
|
match user_inputs["contract"].value: |
|
|
case "None": |
|
|
contract = "false_false" |
|
|
case "One": |
|
|
contract = "true_false" |
|
|
case "Two": |
|
|
contract = "false_true" |
|
|
case _: |
|
|
pass |
|
|
|
|
|
match user_inputs["service"].value: |
|
|
case "None": |
|
|
service = "false_false" |
|
|
case "Basic": |
|
|
service = "true_false" |
|
|
case "Fiber Optic": |
|
|
service = "false_true" |
|
|
case _: |
|
|
pass |
|
|
|
|
|
preds = pl.DataFrame({ |
|
|
"tenure": user_inputs["tenure"].value, |
|
|
"monthly_charges": user_inputs["monthly_charges"].value, |
|
|
"total_charges": user_inputs["total_charges"].value, |
|
|
"contract_One Two year": contract, |
|
|
"internet_service_Fiber No": service, |
|
|
}) |
|
|
|
|
|
prediction = (vot_pipe.predict(preds), vot_pipe.predict_proba(preds)) |
|
|
|
|
|
mo.md(f"Prediction: {"Yes" if prediction[0][0] else "No" }, with about {prediction[1][0][0] * 100 if not prediction[0][0] else prediction[1][0][1] * 100:.2f}% probability.") |
|
|
return contract, prediction, preds, service |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
app.run() |
|
|
|
