Telecommunication Customer Classification

from google.colab import files files.upload()

!ls -lha kaggle.json

!pip install -q kaggle

!mkdir -p ~/.kaggle !cp kaggle.json ~/.kaggle/

!chmod 600 ~/.kaggle/kaggle.json

!ls

!kaggle datasets list

!kaggle datasets download -d rashmiranu/banking-dataset-classification

!unzip banking-dataset-classification.zip

!ls

import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn import preprocessing from sklearn.model_selection import train_test_split

df = pd.read_csv('new_train.csv') # test_df = pd.read_csv('new_test.csv')

df.drop_duplicates(inplace=True) df

df.describe()

df.dropna(inplace=True)

df.describe()

df.drop(['pdays', 'previous'], 1, inplace=True)

df.head()

df.job.unique()

df_obj = df.select_dtypes(include='object').copy() df_obj.columns

# df['y'].replace(['yes', 'no'], [0, 1], inplace=True) df.info()

df_obj.info()

# plotting bar chart for each categorical variable plt.style.use("ggplot") for column in df_obj: plt.figure(figsize=(20,4)) plt.subplot(121) df[column].value_counts().plot(kind="bar") plt.xlabel(column) plt.ylabel("number of customers") plt.title(column)

len(df.columns)

for column in df_obj: mode = df[column].mode()[0] df[column]=df[column].replace('unknown', mode) df.job.unique()

for column in df_obj: plt.figure(figsize=(20,4)) plt.subplot(121) df[column].value_counts().plot(kind="bar") plt.xlabel(column) plt.ylabel("number of customers") plt.title(column)

plt.style.use("ggplot") for column in df_obj: plt.figure(figsize=(20,4)) plt.subplot(121) sns.countplot(df[column], hue=df["y"]) plt.title(column) plt.xticks(rotation=90) # plt.show()

df_encoded = pd.get_dummies(df, columns=['job', 'marital', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'day_of_week', 'poutcome'])

df_encoded df_encoded.head()

X = df_encoded.drop('y', 1).copy() y = df_encoded['y'].copy()

X

X_train, X_test,y_train, y_test = train_test_split(X, y, test_size=0.2)

from sklearn.ensemble import RandomForestClassifier from sklearn.naive_bayes import GaussianNB from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import SVC from sklearn.linear_model import LogisticRegression from sklearn.metrics import confusion_matrix from sklearn.model_selection import RandomizedSearchCV

#KNN Algorthm clf = KNeighborsClassifier() clf.fit(X_train, y_train) Accuracy = clf.score(X_test,y_test) Accuracy

print([int(x) for x in np.linspace(100, 1200, num=6)]) # print(x)

n_estimator = [int(x) for (x) in np.linspace(100, 1200, num=12)] max_depth = [int(x) for x in np.linspace(5, 30, num=6)] min_samples_split = [2, 5, 10, 15, 100] min_samples_leaf = [1, 2, 5, 10] criterion = ['gini', 'entropy']

n_neighbors = [int(x) for x in np.linspace(start = 1, stop = 100, num = 50)] weights = ['uniform','distance'] metric = ['euclidean','manhattan','chebyshev','seuclidean','minkowski'] random_grid = { 'n_neighbors': n_neighbors, 'weights': weights, 'metric': metric, }

knn = KNeighborsClassifier()

KNN = RandomizedSearchCV(knn, param_distributions=random_grid, verbose=2, cv=3, random_state=42, n_iter=10, scoring='accuracy')

KNN.fit(X_train, y_train)

KNN.best_params_

best_knn = KNeighborsClassifier(metric= 'manhattan', n_neighbors= 55, weights= 'distance')

best_knn.fit(X_train, y_train)

best_knn.score(X_test, y_test)

clf = LogisticRegression() clf.fit(X_train, y_train) Accuracy = clf.score(X_test,y_test) Accuracy

param_dist = { 'penalty' : ['l1', 'l2'], 'C' : [0, 1, 2, 3, 4] }

logreg = LogisticRegression()

LG = RandomizedSearchCV(logreg, param_distributions=param_dist, verbose=2, cv=3, random_state=42, n_iter=10, scoring='accuracy')

LG.fit(X_train, y_train)

LG.best_params_

LG.best_score_

lg_best = LogisticRegression(C = 3, penalty='l2') lg_best.fit(X_train, y_train) lg_best.score(X_test, y_test)

clf = GaussianNB() clf.fit(X_train, y_train) clf.score(X_test, y_test)

params_NB = {'var_smoothing': np.logspace(0,-9, num=100)} NB = GaussianNB()

NB_ran = RandomizedSearchCV(NB, param_distributions=params_NB, verbose=2, cv=3, random_state=42, n_iter=10, scoring='accuracy')

NB_ran.fit(X_train, y_train)

NB_ran.best_params_

NB_ran.best_score_

NB_best = GaussianNB(var_smoothing=1.51991108295293320)

NB_best.fit(X_train, y_train) NB_best.score(X_test, y_test)

clf = RandomForestClassifier() clf.fit(X_train, y_train) clf.score(X_test, y_test)

param_dist = { "n_estimators" : n_estimator, "max_depth" : max_depth, "min_samples_leaf":min_samples_leaf, "criterion":criterion, "min_samples_split":min_samples_split }

rf = RandomForestClassifier()

rb_hyper = RandomizedSearchCV(rf, param_distributions=param_dist, verbose=2, cv=3, random_state=42, n_iter=10, scoring='accuracy')

rb_hyper.fit(X_train, y_train)

rb_hyper.best_params_

rb_hyper.best_score_

best_rf = RandomForestClassifier(criterion= 'gini', max_depth=30, min_samples_leaf= 1, min_samples_split= 15, n_estimators= 300)

best_rf.fit(X_train, y_train) best_rf.score(X_test, y_test)

clf = SVC() clf.fit(X_train, y_train) clf.score(X_test, y_test)

param_dist = {'C': [0.1, 1, 10, 100, 1000], 'gamma': [1, 0.1, 0.01, 0.001, 0.0001], 'kernel': ['rbf']}

svc_hyper = RandomizedSearchCV(SVC(), param_distributions=param_dist, verbose=2, cv=3, random_state=42, n_iter=10, scoring='accuracy')

svc_hyper.fit(X_train, y_train)

svc_hyper.best_params_

svc_hyper.best_score_

best_svc = SVC(C=1000, gamma=0.001, kernel='rbf') best_svc.fit(X_train, y_train) best_svc.score(X_test, y_test)