Customer's Online Shopping Purchasing Intention¶

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt
import seaborn as sns 
import math
sns.set()

filepath = r'C:\Users\azuka\Drive Folder\ML projects\Leapsapp\browsing or purchasing\Rename.csv'
data = pd.read_csv(filepath, sep=';')
# data

def check_values(df):
    col_desc = []
    data = {
        'features': [col for col in df.columns],
        'data_type': [df[col].dtype for col in df.columns],
        'nan_total': [df[col].isna().sum() for col in df.columns],
        'nan_pct': [round(df[col].isna().sum()/len(df)*100,2) for col in df.columns],
        'unique': [df[col].nunique() for col in df.columns],
        'values_ex': [df[col].drop_duplicates().sample(df[col].nunique()).values if df[col].nunique() <= 5 else df[col].drop_duplicates().sample(2).values for col in df.columns]
    }
    return pd.DataFrame(data)

def plot_kdeplot(features):
    feat_len = len(features)
    if feat_len > 3:
        nrows = math.ceil(feat_len/4)
        ncols = math.ceil(feat_len/3)
    else:
        nrows=3
        ncols=4
    
    fig, ax = plt.subplots(nrows, ncols, figsize=(ncols*4, nrows*3))
    for i, col in enumerate(features):
        if feat_len > 3:
            plt.subplot(nrows,ncols,i+1)
            g=sns.kdeplot(data[data.HasPurchased==1][col], label='Purchase')
            g=sns.kdeplot(data[data.HasPurchased==0][col], label='No Puchase')
            g.legend()
        else:
            sns.kdeplot(data[data.HasPurchased==1][col], label='Purchase', ax=ax[i])
            sns.kdeplot(data[data.HasPurchased==0][col], label='No Puchase', ax=ax[i])
            ax[i].legend()
    for j in range(nrows*ncols-feat_len):
        if feat_len > 3:
            ax[-1,-(j+1)].axis('off')
        else: ax[-(j+1)].axis('off')
    plt.tight_layout()

from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold, cross_validate, GridSearchCV, ShuffleSplit, learning_curve, StratifiedShuffleSplit
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.metrics import classification_report, plot_roc_curve, plot_precision_recall_curve, \
precision_recall_curve, plot_confusion_matrix, confusion_matrix, ConfusionMatrixDisplay, precision_score, f1_score, accuracy_score
from imblearn.pipeline import Pipeline
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier, RandomForestClassifier, ExtraTreesClassifier
from imblearn.over_sampling import SMOTE, RandomOverSampler
from imblearn.under_sampling import RandomUnderSampler, TomekLinks, EditedNearestNeighbours
from imblearn.combine import SMOTETomek, SMOTEENN

from sklearn.preprocessing import MinMaxScaler, RobustScaler, OneHotEncoder, OrdinalEncoder
from xgboost.sklearn import XGBClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.feature_selection import RFE
import category_encoders as ce
from sklearn.compose import ColumnTransformer
import pickle

df_train = data.copy()

cat_cols = [x for x in cat_cols if x != 'Weekend']

for col in cat_cols:
    df_train[col] = df_train[col].astype('object')

df_train = pd.get_dummies(df_train, drop_first=True)

X = df_train.drop(columns=['HasPurchased'])
y = df_train['HasPurchased']

X_train_val, X_test, y_train_val, y_test = train_test_split(X,y, random_state=26, stratify=y)

def pipe_model(models):
    pipelines = []
    for model in models:
        pl = Pipeline([
        # ('transfr', transformer),
        # ('scaler', MinMaxScaler()),
#         ('rfe', RFE(model[1])),
#         ('sampling', RandomOverSampler(sampling_strategy=0.1)),
#         ('sampling2', RandomUnderSampler(sampling_strategy=0.5)),
        # ('sampling', SMOTEENN(enn=EditedNearestNeighbours(sampling_strategy='majority'))),
        ('model', model[1])
])
        pipelines.append(pl)
    return pipelines

def pipe_scale_model(models):
    pipelines = []
    for model in models:
        pl = Pipeline([
        # ('transfr', transformer),
        ('scaler', RobustScaler()),
#         ('rfe', RFE(model[1])),
#         ('sampling', RandomOverSampler(sampling_strategy=0.1)),
#         ('sampling2', RandomUnderSampler(sampling_strategy=0.5)),
        # ('sampling', SMOTEENN(enn=EditedNearestNeighbours(sampling_strategy='majority'))),
        ('model', model[1])
])
        pipelines.append(pl)
    return pipelines

def pipe_smote_model(models):
    pipelines = []
    for model in models:
        pl = Pipeline([
        # ('transfr', transformer),
        # ('scaler', RobustScaler()),
#         ('rfe', RFE(model[1])),
        ('sampling', SMOTE()),
#         ('sampling2', RandomUnderSampler(sampling_strategy=0.5)),
        # ('sampling', SMOTEENN(enn=EditedNearestNeighbours(sampling_strategy='majority'))),
        ('model', model[1])
])
        pipelines.append(pl)
    return pipelines

def pipe_scale_smote_model(models):
    pipelines = []
    for model in models:
        pl = Pipeline([
        # ('transfr', transformer),
        ('scaler', MinMaxS()),
#         ('rfe', RFE(model[1])),
        ('sampling', SMOTE()),
#         ('sampling2', RandomUnderSampler(sampling_strategy=0.5)),
        # ('sampling', SMOTEENN(enn=EditedNearestNeighbours(sampling_strategy='majority'))),
        ('model', model[1])
])
        pipelines.append(pl)
    return pipelines

def model_evaluation(pipes, metric):
    skfold = StratifiedKFold(n_splits=5, random_state=26, shuffle=True)
    model_cvs = []
    for pipe in pipes:
        model_cv = cross_validate(pipe, X_train_val, y_train_val, cv=skfold, scoring=metric, return_train_score=True, n_jobs=4)
        model_cvs.append(model_cv)
    return model_cvs

def results_dataframe(models, model_cvs, metric):
    scores = np.zeros((len(models),len(metric)*2))
    j = 0
    for model, model_cv in zip(models, model_cvs):
        
        model_score = []
        for i in model_cv:
            
            if i == 'fit_time' or i == 'score_time':
                continue
            model_score.append(model_cv[i].mean())
        scores[j] = model_score
        j+=1
    return pd.DataFrame(scores, index=[i[0] for i in models], columns = [i for i in list(model_cv_1[0].keys()) if i not in ('fit_time', 'score_time')])

def summary_df(name):
    return pd.concat([df_model[[name]].rename(columns={name:'model'}),
           df_model2[[name]].rename(columns={name:'Scaling+model'}),
           df_model4[[name]].rename(columns={name:'SMOTE+model'}),
           df_model3[[name]].rename(columns={name:'Scaling+SMOTE+model'})], axis=1).round(3)

# pl_3[0].set_params(model__solver='saga', model__max_iter=500)

def plot_learning_curve_scoring(estimator, title, X, y, axes=None, ylim=None, cv=None, scoring=None,
                        n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):
    """
    Generate 3 plots: the test and training learning curve, the training
    samples vs fit times curve, the fit times vs score curve.

    Parameters
    ----------
    estimator : estimator instance
        An estimator instance implementing `fit` and `predict` methods which
        will be cloned for each validation.

    title : str
        Title for the chart.

    X : array-like of shape (n_samples, n_features)
        Training vector, where ``n_samples`` is the number of samples and
        ``n_features`` is the number of features.

    y : array-like of shape (n_samples) or (n_samples, n_features)
        Target relative to ``X`` for classification or regression;
        None for unsupervised learning.

    axes : array-like of shape (3,), default=None
        Axes to use for plotting the curves.

    ylim : tuple of shape (2,), default=None
        Defines minimum and maximum y-values plotted, e.g. (ymin, ymax).

    cv : int, cross-validation generator or an iterable, default=None
        Determines the cross-validation splitting strategy.
        Possible inputs for cv are:

          - None, to use the default 5-fold cross-validation,
          - integer, to specify the number of folds.
          - :term:`CV splitter`,
          - An iterable yielding (train, test) splits as arrays of indices.

        For integer/None inputs, if ``y`` is binary or multiclass,
        :class:`StratifiedKFold` used. If the estimator is not a classifier
        or if ``y`` is neither binary nor multiclass, :class:`KFold` is used.

        Refer :ref:`User Guide <cross_validation>` for the various
        cross-validators that can be used here.

    n_jobs : int or None, default=None
        Number of jobs to run in parallel.
        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
        for more details.

    train_sizes : array-like of shape (n_ticks,)
        Relative or absolute numbers of training examples that will be used to
        generate the learning curve. If the ``dtype`` is float, it is regarded
        as a fraction of the maximum size of the training set (that is
        determined by the selected validation method), i.e. it has to be within
        (0, 1]. Otherwise it is interpreted as absolute sizes of the training
        sets. Note that for classification the number of samples usually have
        to be big enough to contain at least one sample from each class.
        (default: np.linspace(0.1, 1.0, 5))
    """
#     if axes is None:
#         _, axes = plt.subplots(1, 3, figsize=(20, 5))
    _, axes = plt.subplots()

    axes.set_title(title)
    if ylim is not None:
        axes.set_ylim(*ylim)
    axes.set_xlabel("Training examples")
    axes.set_ylabel("Score")

    train_sizes, train_scores, test_scores, fit_times, _ = \
        learning_curve(estimator, X, y, cv=cv, n_jobs=n_jobs,
                       train_sizes=train_sizes, scoring=scoring,
                       return_times=True)
    train_scores_mean = np.mean(train_scores, axis=1)
    train_scores_std = np.std(train_scores, axis=1)
    test_scores_mean = np.mean(test_scores, axis=1)
    test_scores_std = np.std(test_scores, axis=1)

    # Plot learning curve
    axes.grid()
    axes.fill_between(train_sizes, train_scores_mean - train_scores_std,
                         train_scores_mean + train_scores_std, alpha=0.1,
                         color="r")
    axes.fill_between(train_sizes, test_scores_mean - test_scores_std,
                         test_scores_mean + test_scores_std, alpha=0.1,
                         color="g")
    axes.plot(train_sizes, train_scores_mean, 'o-', color="r",
                 label="Training score")
    axes.plot(train_sizes, test_scores_mean, 'o-', color="g",
                 label="Cross-validation score")
    axes.legend(loc="best")

    return plt