| 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() |
|
|
