Client Segments Data Simulation & Cost Sensitive Multi-classification

import numpy as np
import pandas as pd

pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 70)

segment_variables = [
                     'age', 
                     'gender',
                     'annual_income', 
                     'willingness_to_leave', 
                     'annual_branch_visits', 
                     'service_satisfaction_level', # scale 1-5
                     'use_debit_services', 
                     'use_online_mobile', 
                     'deposit_revenue',

                     #'knowledgeable'
                     
                    ]
segment_variables_distribution = dict(zip(segment_variables,
                                          [
                                            'normal',
                                           'binomial',
                                           'normal', 
                                           'binomial',
                                           'poisson',
                                           'custom_discrete',
                                           'binomial',
                                           'binomial',
                                           #'binomial',
                                           'normal',

                                           #'binomial'
                                          ]
                                           ))

segment_variables_distribution['age']

segment_variables_distribution

segment_means = {'marginalised_middles':        [43, 0.45, 55000, 0.2, 6, None, 0.8, 0.7, 1000],
                 'disengaged_skeptics':         [54, 0.6, 38000, 0.5, 14, None, 0.2, 0.2, 340],
                 'satisfied_traditionalists':   [64, 0.55, 59000, 0.05, 30, None, 0.9, 0.15, 1200],
                 'struggling_techies':          [25, 0.45, 25000, 0.4, 2, None, 0.7, 0.9, 200],
                 'sophisticated_opportunists':  [45.5, 0.4, 70000, 0.2, 11, None, 0.9, 0.7, 2400]}

# standard deviations for each segment where applicable

segment_stddev = {'marginalised_middles':        [7, None, 10000, None, None, None, None, None,300],
                  'disengaged_skeptics':         [12, None, 7000, None, None, None, None, None, 120],
                  'satisfied_traditionalists':   [8, None, 11000, None, None, None, None, None,400],
                  'struggling_techies':          [4, None, 6000, None, None, None, None, None,80],
                  'sophisticated_opportunists':  [8, None, 16000, None, None, None, None, None,1000]}

# discrete variable probabilities
segment_pdist  = {'marginalised_middles':        [None, None, None, None, None,(0.05, 0.20, 0.35, 0.25, 0.15),None, None, None],
                  'disengaged_skeptics':         [None, None, None, None, None,(0.25, 0.25, 0.30, 0.15, 0.05),None, None, None],
                  'satisfied_traditionalists':   [None, None, None, None, None,(0.05, 0.10, 0.25, 0.30, 0.30),None, None, None],
                  'struggling_techies':          [None, None, None, None, None,(0.15, 0.25, 0.35, 0.20, 0.05),None, None, None],
                  'sophisticated_opportunists':  [None, None, None, None, None,(0.05, 0.15, 0.30, 0.25, 0.25),None, None, None]
                 }

segment_names = ['marginalised_middles', 'disengaged_skeptics', 'satisfied_traditionalists', 'struggling_techies',
                 'sophisticated_opportunists']
segment_sizes = dict(zip(segment_names,[180, 60, 160, 60, 40]))

segment_statistics = {}
for name in segment_names:
  segment_statistics[name] = {'size': segment_sizes[name]}
  for i, variable in enumerate(segment_variables):
    segment_statistics[name][variable] = {
        'mean': segment_means[name][i],
        'stddev': segment_stddev[name][i],
        'pdist': segment_pdist[name][i]
    }

#np.random.seed(seed=0)
from numpy.random import default_rng
from numpy.random import Generator, PCG64
from scipy import stats
rng = default_rng(0)
#rg = Generator(PCG64())
segment_constructor = {}

# Iterate over segments to create data for each
for name in segment_names:
  segment_data_subset = {}
  print('segment: {0}'.format(name))
  # Within each segment, iterate over the variables and generate data
  for variable in segment_variables:
    #print('\tvariable: {0}'.format(variable))
    if segment_variables_distribution[variable] == 'normal':
     
      #print(segment_statistics[name][variable]['mean'], segment_statistics[name][variable]['stddev'],segment_statistics[name]['size'] )
        # Draw random normals
      segment_data_subset[variable] = np.maximum(0, np.round(rng.normal(
          
          loc=segment_statistics[name][variable]['mean'],
          scale=segment_statistics[name][variable]['stddev'],
          size=segment_statistics[name]['size']
          
      ),2))
    elif segment_variables_distribution[variable] == 'poisson':
      # Draw counts
      segment_data_subset[variable] = rng.poisson(
          lam=segment_statistics[name][variable]['mean'],
          size=segment_statistics[name]['size']
      )
    elif segment_variables_distribution[variable] == 'binomial':
      # Draw binomials
      segment_data_subset[variable] = rng.binomial(
          n=1,
          p=segment_statistics[name][variable]['mean'],
          size=segment_statistics[name]['size']
      )
    elif segment_variables_distribution[variable] == 'custom_discrete':
      # Draw custom discrete ordinal variable
      xk = 1 + np.arange(5) # ordinal scale 1-5
      pk = segment_statistics[name][variable]['pdist']
      custm = stats.rv_discrete(name='custm', values=(xk, pk))
      segment_data_subset[variable] = custm.rvs(
          size=segment_statistics[name]['size']
      )
    else:
      # Data type unknown
      print('Bad segment data type: {0}'.format(
          segment_variables_distribution[j])
           )
      raise StopIteration
  segment_data_subset['Segment'] = np.repeat(
      name,
      repeats=segment_statistics[name]['size']
  )
  #print(segment_data_subset)
    
  segment_constructor[name] = pd.DataFrame(segment_data_subset)

segment_data = pd.concat(segment_constructor.values())
#segment_data.reindex(range(0,500,1))
segment_data.index = range(0,len(segment_data),1)

segment_data.index

np.random.seed(seed=2554)
name = 'sophisticated_opportunists'
variable = 'age'
print(segment_statistics[name][variable]['mean'])
print(segment_statistics[name][variable]['stddev'])
np.random.normal(
    loc=segment_statistics[name][variable]['mean'],
    scale=segment_statistics[name][variable]['stddev'],
    size=10
)

np.random.seed(seed=1)
variable = 'annual_branch_visits'
print(segment_statistics[name][variable]['mean'])
print(segment_statistics[name][variable]['stddev'])
np.random.poisson(
    lam=segment_statistics[name][variable]['mean'],
    size=10
)

np.random.seed(seed=2554)
variable = 'use_online_mobile'
print(segment_statistics[name][variable]['mean'])
print(segment_statistics[name][variable]['stddev'])
np.random.binomial(
    n=1,
    p=segment_statistics[name][variable]['mean'],
    size=10
)

np.repeat(name, repeats=10)

# codings

segment_data['gender'] = segment_data['gender'].apply(
    lambda x: 'male' if x else 'female'
)
segment_data['use_online_mobile'] = segment_data['use_online_mobile'].apply(
    lambda x: True if x else False
)
segment_data['use_debit_services'] = segment_data['use_debit_services'].apply(
    lambda x: True if x else False
)
segment_data['willingness_to_leave'] = segment_data['willingness_to_leave'].apply(
    lambda x: True if x else False
)

# number adjustments
segment_data['service_satisfaction_level'] = segment_data['service_satisfaction_level'].apply(
    lambda x: np.minimum(x, 5)
)

segment_data.describe(include='all').T

# overview variable distributions by segment

segment_data.groupby('Segment').describe().T

import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style("dark")
plt.figure(figsize=(10,7))

sns.boxplot(y='Segment', x='annual_branch_visits', hue='use_debit_services', data=segment_data, 
             orient='h')

plt.figure(figsize=(10,7))
sns.boxplot(y='Segment', x='annual_branch_visits', hue='use_online_mobile', data=segment_data, 
             orient='h')

sns.catplot(y='Segment', x='deposit_revenue', hue='use_online_mobile', col="gender",
                data=segment_data, kind="box", height=9, 
                aspect=.7);

plt.figure(figsize=(8,6))
sns.scatterplot(data=segment_data, x="age", y="annual_income", hue=segment_data.Segment)

plt.figure(figsize=(8,6))
sns.scatterplot(data=segment_data, x="annual_branch_visits", y="deposit_revenue", hue=segment_data.Segment)

plt.figure(figsize=(8,6))
sns.scatterplot(data=segment_data, x="annual_branch_visits", y="annual_income", hue=segment_data.Segment)

plt.figure(figsize=(8,6))
sns.scatterplot(data=segment_data, x=segment_data.service_satisfaction_level + np.random.normal(scale=0.08,
size=sum(segment_sizes.values())) , y="age", hue=segment_data.Segment)
plt.legend(bbox_to_anchor=(1,1), loc="upper left")

# create the main dataframe
#from sklearn import preprocessing
df = segment_data.copy()

df.describe(include='all').T

df.groupby('Segment').describe(include='all')

print(segment_data.dtypes)
df.dtypes.value_counts()

# frequencies plotted in Histogramms
import warnings
with warnings.catch_warnings():
    warnings.simplefilter('ignore')
    
f, axes = plt.subplots(3,4, figsize=(20, 20))
for ax, feature in zip(axes.flat, df.columns):
    sns.histplot(df[feature], ax=ax)

# column pairwise correlations
plt.figure(figsize=(8,8))
sns.heatmap(df.corr('pearson'),annot = True, fmt='.2g', square=True)

### ppscore package ###
import ppscore as pps
def heatmap(df):
    plt.rcParams['figure.figsize'] = (11,7)
    df = df[['x', 'y', 'ppscore']].pivot(columns='x', index='y', values='ppscore')
    ax = sns.heatmap(df, vmin=0, vmax=1, linewidths=0.5, annot=True)
    ax.set_title("PPS matrix")
    ax.set_xlabel("feature")
    ax.set_ylabel("target")
    return ax
def corr_heatmap(df):
    ax = sns.heatmap(df, vmin=-1, vmax=1, linewidths=0.5, annot=True)
    ax.set_title("Correlation matrix")
    return ax
### ppscore package ###

ppsmatrix = pps.matrix(df)
heatmap(ppsmatrix)

import seaborn as sns
sns.set(style="ticks", color_codes=True)
sns.set_style("dark")

plt.figure(figsize=(15,15))
customgrid = sns.pairplot(df, hue="Segment")
customgrid.map_upper(plt.scatter, linewidths=1, s=5, alpha=0.5)
plt.show()

res = sns.relplot(data=df, x='annual_income', y='age', hue="Segment", alpha=0.6, col="use_online_mobile")

# https://gist.github.com/kylerbrown/29ce940165b22b8f25f4

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns # improves plot aesthetics
from textwrap import wrap
import matplotlib.patches as mpatches

def _invert(x, limits):
    """inverts a value x on a scale from
    limits[0] to limits[1]"""
    return limits[1] - (x - limits[0])

def _scale_data(data, ranges):
    """scales data[1:] to ranges[0],
    inverts if the scale is reversed"""
    for d, (y1, y2) in zip(data[1:], ranges[1:]):
        #print( d, (y1, y2))
        assert (y1 <= d <= y2) or (y2 <= d <= y1)
    x1, x2 = ranges[0]
    d = data[0]
    if x1 > x2:
        d = _invert(d, (x1, x2))
        x1, x2 = x2, x1
    sdata = [d]
    for d, (y1, y2) in zip(data[1:], ranges[1:]):
        if y1 > y2:
            d = _invert(d, (y1, y2))
            y1, y2 = y2, y1
        sdata.append((d-y1) / (y2-y1) 
                     * (x2 - x1) + x1)
    return sdata

class ComplexRadar():
    def __init__(self, fig, variables, ranges,
                 n_ordinate_levels=6):
        angles = np.arange(0, 360, 360./len(variables))

        axes = [fig.add_axes([0.1,0.1,0.9,0.9],polar=True,
                label = "axes{}".format(i)) 
                for i in range(len(variables))]
        l, text = axes[0].set_thetagrids(angles, 
                                         labels=variables)
        
        [txt.set_rotation(angle-90) for txt, angle 
             in zip(text, angles)]
        
        for ax in axes[1:]:
            ax.patch.set_visible(False)
            ax.grid("off")
            ax.xaxis.set_visible(False)
        for i, ax in enumerate(axes):
            grid = np.linspace(*ranges[i], 
                               num=n_ordinate_levels)
            gridlabel = ["{}".format(round(x,1)) 
                         for x in grid]
            if ranges[i][0] > ranges[i][1]:
                grid = grid[::-1] # hack to invert grid
                          # gridlabels aren't reversed
            gridlabel[0] = "" # clean up origin
            ax.set_rgrids(grid, labels=gridlabel,
                         angle=angles[i])
            #ax.spines["polar"].set_visible(False)
            ax.set_ylim(*ranges[i])
        # variables for plotting
        self.angle = np.deg2rad(np.r_[angles, angles[0]])
        self.ranges = ranges
        self.ax = axes[0]
    def plot(self, data, *args, **kw):
        sdata = _scale_data(data, self.ranges)
        r = self.ax.plot(self.angle, np.r_[sdata, sdata[0]], *args, **kw)
        return r
    def fill(self, data, *args, **kw):
        sdata = _scale_data(data, self.ranges)
        self.ax.fill(self.angle, np.r_[sdata, sdata[0]], *args, **kw)
    def legend(self, *args, **kw):
        self.ax.legend(self, *args, **kw)

# prepare data to be plotted in the segment profiles        
criteria = ('age', 'gender', 'annual_income', 'willingness_to_leave',
       'annual_branch_visits', 'service_satisfaction_level',
       'use_debit_services', 
            'use_online_mobile', 'deposit_revenue')

segmeans = df.copy()
segmeans['gender'] = segmeans['gender'].apply(lambda x: 1 if x == 'male' else 0)

segmeans['willingness_to_leave'] = segmeans['willingness_to_leave'].apply(lambda x: 1 if x == True else 0)
segmeans['use_debit_services'] = segmeans['use_debit_services'].apply(lambda x: 1 if x == True else 0)
segmeans['use_online_mobile'] = segmeans['use_online_mobile'].apply(lambda x: 1 if x == True else 0)

segmeans = segmeans.groupby('Segment').mean()

segs = df.Segment.unique()

#test = segdata.get('marginalised_middles')

data=[]
segdata = dict()

for seg in segs:
    #for crit in criteria:
    data.append(segmeans.loc[seg])
    
    segdata.update({seg: data})
    data = []

ranges = []
for col in segmeans.columns:
    #print(df[col].dtype)
    distance = 0.2 # increase in case of assert errors
    if segmeans[col].dtype != 'object' and segmeans[col].dtype != 'bool':
        lower = min(segmeans[col])- min(segmeans[col])* distance
        upper = max(segmeans[col])+ max(segmeans[col])* distance
        if upper > 10:
            upper = round(upper,0)
            lower = round(lower,0)
        else:
            upper = round(upper,1)
            lower = round(lower,1)
        ranges.append((lower,upper))

# plotting



plt.rc('xtick', labelsize=8) 
plt.rc('ytick', labelsize=8) 
i=0
for key, value in segdata.items():
    #print(key, value)
    #plt.title(key)
    radar = ComplexRadar(plt.figure(figsize=(6, 6), dpi = 100), criteria, ranges)
    radar.plot(tuple(value[0]))
    radar.fill(tuple(value[0]), alpha=0.2)
    #plt.tight_layout(pad=2)
    plt.title('Segment ' + str(key), loc='left')
     
plt.show()  

import warnings
warnings.filterwarnings('ignore')
#ignore neglible user warning for legend params

comparisons = [['disengaged_skeptics', 'marginalised_middles'],
             ['satisfied_traditionalists', 'sophisticated_opportunists'],
             ['struggling_techies', 'disengaged_skeptics']]

for comparison in comparisons:
    segdatasliced = {key: segdata[key] for key in segdata.keys() & comparison}
    
    radar = ComplexRadar(plt.figure(figsize=(6, 6), dpi = 100), criteria, ranges)
    #init
    title = ''
    ha=[]
    la=[]
    for key, value in segdatasliced.items():
        r = radar.plot(tuple(value[0]))
        radar.fill(tuple(value[0]), alpha=0.2)
        
        patch = mpatches.Patch(color=r[0].get_color(), label=key)
        ha.append(patch)
        la.append(key)
        #radar.legend(, loc=1)
        #plt.tight_layout(pad=2)
        
        if len(title) > 1:
            title = 'Segment Means Profile Comparison: ' + title + ' vs. ' + key
        else:
            title = key
            
    radar.legend(handles=ha, labels=la, loc=1, bbox_to_anchor=(0.1, 0.1))
    plt.title('\n'.join(wrap(title,40)), loc='left',   x=-0.3, y=0.94, pad=14)
    plt.show()

# looks like not needed anymore

"""df_test = df_unlabeled.copy()
df_test['Segment'] = segment_data.Segment
df_test.head()"""

"""import pandas as pd, numpy as np
from sklearn.preprocessing import MultiLabelBinarizer
import warnings
warnings.filterwarnings("ignore")

segm = df.copy()"""

# copy as df
segm = df.copy()

segm['gender'] = segm['gender'].apply(
    lambda x: 1 if x == 'male' else 0
)
segm['use_online_mobile'] = segm['use_online_mobile'].apply(
    lambda x: 1 if x else 0
)
segm['use_debit_services'] = segm['use_debit_services'].apply(
    lambda x: 1 if x else 0
)
segm['willingness_to_leave'] = segm['willingness_to_leave'].apply(
    lambda x: 1 if x else 0
)

# copy as numpy array
segm_array = df.copy().values

X = segm_array[:, :segm.shape[1] - 1]
y = segm_array[:, segm.shape[1] - 1] 

# Variance Inflation Factor Check for Multicollinearity

from statsmodels.stats.outliers_influence import variance_inflation_factor
from statsmodels.tools.tools import add_constant

df_vif = add_constant(segm.iloc[:,:-1])
pd.Series([variance_inflation_factor(df_vif.values, i) for i in range(df_vif.shape[1])], index=df_vif.columns)

features = segm.iloc[:,:-1]

# correlation matrix
corr = np.corrcoef(features, rowvar=0)

# eigen values & eigen vectors
w, v = np.linalg.eig(corr)

# eigen vector of a predictor
# pd.Series(v[:,3], index=segm.iloc[:,:-1].columns)

pd.Series(w, index=features.columns)

# Needed to run the logistic regression
import statsmodels.formula.api as smf

# For plotting/checking assumptions
import seaborn as sns

df_check = segm.copy()

df_check['gender'] = df['gender'].astype('category')
df_check['use_online_mobile'] = df['use_online_mobile'].astype('category')
df_check['use_debit_services'] = df['use_debit_services'].astype('category')
df_check['willingness_to_leave'] = df['willingness_to_leave'].astype('category')


mapdict = dict(zip( df_check.Segment.unique(), range(0,5)))
df_check['Segment'] = df_check.Segment.map(mapdict)

#df_check['Segment'] = df['Segment'].astype('category')
df_check = pd.get_dummies(df_check)
df_check.to_csv('df_check.csv', index=False)

#dummy_segs = df_check.iloc[:,-5:].columns
predictors = df_check.iloc[:,:9].columns

## sklearn
from sklearn.linear_model import LogisticRegression

# Logistic Regression
testmodel = LogisticRegression(multi_class='multinomial')
testmodel.fit(df_check.iloc[:,:-1], df_check['Segment'])

# only for the purpose of this assumption test we predict with training data
probabilities = testmodel.predict_proba(df_check.iloc[:,:-1])

logodds = pd.DataFrame(np.log(probabilities/(1-probabilities)))
logodds.head()

class_list = list(df.Segment.unique())
#yy = 10/pow(df_check.service_satisfaction_level + 3, 5)
#yy = df_check.service_satisfaction_level
yy = df_check.age
xx = logodds.iloc[:,4] # logodds for one class
from statsmodels.nonparametric.smoothers_lowess import lowess as  sm_lowess

plt.figure(figsize=(14,14))
plt.title('predictor age')

cols = 2
rows = np.ceil(len(df.Segment.unique()) / cols)

for i in range(0,len(df.Segment.unique())):
    ax = plt.subplot(rows, cols, i + 1) 
    sm_y, sm_x = sm_lowess(yy, logodds.iloc[:,i],  frac=3./5., it=5, return_sorted = True).T
    plt.plot(sm_x, sm_y, color='tomato', linewidth=3)
    plt.plot(yy,logodds.iloc[:,i], 'k.')
    ax.set_title(class_list[i])
    ax.set_xlabel("age")
    ax.set_ylabel("log odds")
    
plt.show()

# all continuous variables to transform
df_boxtidwell = df_check.copy()
df_boxtidwell = df_boxtidwell.drop(df_boxtidwell[df_boxtidwell.annual_branch_visits == 0].index)
df_boxtidwell = df_boxtidwell.drop(df_boxtidwell[df_boxtidwell.deposit_revenue == 0].index)
df_boxtidwell = df_boxtidwell.drop(df_boxtidwell[df_boxtidwell.annual_income == 0].index)
df_boxtidwell = df_boxtidwell.drop(df_boxtidwell[df_boxtidwell.service_satisfaction_level == 0].index)

# Define continuous variables
z=5
continuous_var = df_boxtidwell.iloc[:, 0:z].columns

# Add logit transform interaction terms (natural log) for continuous variables e.g. Age * Log(Age)
for var in continuous_var:
    df_boxtidwell[f'Transf_{var}'] = df_boxtidwell[var].apply(lambda x: x * np.log(x) ) #np.log = natural log

df_boxtidwell.head()
#continuous_var
cols = continuous_var.append(df_boxtidwell.iloc[:, -z:].columns)
cols

import statsmodels.api as sm

# Redefine independent variables to include interaction terms
#X_lt = df_boxtidwell[cols[-5:]]
X_lt = df_boxtidwell[cols]
#_lt = df_boxtidwell['deposit_revenue']
y_lt = df_boxtidwell['Segment']

# Add constant
X_lt = sm.add_constant(X_lt, prepend=False)
  
# Build model and fit the data (using statsmodel's Logit)
logit_result = sm.GLM(y_lt, X_lt, family=sm.families.Binomial()).fit()

# Display summary results
print(logit_result.summary())

import pandas as pd, numpy as np

# assymmetric nonreciprocal costs of classification errors
# true class vs. wrong predicted class costs

true_vs_predicted_class_cost = pd.DataFrame(index=segment_names, columns=segment_names)

true_vs_predicted_class_cost.marginalised_middles       = [0,10,10,10,10]
true_vs_predicted_class_cost.disengaged_skeptics        = [10,0, 10, 10, 10]
true_vs_predicted_class_cost.satisfied_traditionalists  = [10,10, 0, 10, 10]
true_vs_predicted_class_cost.struggling_techies         = [10,10, 10, 0, 10]
true_vs_predicted_class_cost.sophisticated_opportunists = [200,34, 40, 25, 0]

true_vs_predicted_class_cost = true_vs_predicted_class_cost.T # transpose the column-wise-built DataFrames
true_vs_predicted_class_cost 

# for computation we map the class labels to numeric classes

# map class labels numerically
d = dict([(y,x) for x,y in enumerate((segment_names))])

# convert to numeric indices
true_vs_predicted_class_cost.columns = d.values()
true_vs_predicted_class_cost.index = d.values()

true_vs_predicted_class_cost

import random
true_vs_predicted_class_cost

# map observations class string labels to number

# convert to np array
cost_matrix = true_vs_predicted_class_cost.values

try:
    y = [d[s] for s in y]
except:
    print('already done') 

# new cost array for package 'costsensitive'
C = np.array([cost_matrix[i] for i in y])
np.random.seed(1)
#C = (np.random.random_sample((500, 5))/100 + 1) * C

#C = np.linalg.inv(C)

# save cost matrix to csv file
# np.savetxt('costmatrix.csv', C, delimiter=',')

C

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, MinMaxScaler

#segm = segm.values
X = segm.iloc[:, :segm.shape[1] - 1].astype('float64')
y = segm.iloc[:, segm.shape[1] - 1] 

"""# numerical labels
try:
    y = [d[s] for s in y]
except:
    print('already done') """

# numerical labels
nummap = dict(zip(segment_names,range(0,5)))
y = y.map(nummap)

X_train, X_test, C_train, C_test, y_train, y_test = train_test_split(X, C, y, test_size=.5, random_state=0,
                                                                     stratify=y
                                                                    )
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

from sklearn import svm
from sklearn.metrics import confusion_matrix

### Keeping track of the results for later
name_algorithm = list()
f1_scores = list()
costs = list()
collect_conf_mat = list()

#### Baseline : Classic SVM with no weights

svm_model = svm.SVC(random_state=1)
svm_model.fit(X_train, y_train)

preds_svm = svm_model.predict(X_test)

from sklearn.metrics import precision_recall_fscore_support, f1_score

conf_mat = confusion_matrix(y_test, preds_svm)

f1 = f1_score(y_test, preds_svm, zero_division=1, average='weighted')
f1

# logging results
name_algorithm.append("Classic Support Vector Machine SVC Method")
f1_scores.append(f1)
# ex post calculation of costs with the baseline model

costs.append( C_test[np.arange(C_test.shape[0]), preds_svm].sum() )
collect_conf_mat.append(confusion_matrix(y_test, preds_svm))

from sklearn.metrics import plot_confusion_matrix

disp = plot_confusion_matrix(svm_model, X_test, y_test,
                                 display_labels=segment_names,
                                 cmap=plt.cm.Blues)
disp.ax_.set_xticklabels(segment_names, size=12, rotation=30, ha='right')
plt.grid(False)
plt.show()

pd.DataFrame(precision_recall_fscore_support(y_test, preds_svm), columns=segment_names, index=['precision', 'recall', 'fscore', 'support'])

from costsensitive import WeightedAllPairs, WeightedOneVsRest, RegressionOneVsRest, FilterTree, CostProportionateClassifier
from sklearn import svm

### 1: WAP = Weighted All-Pairs as described in "Error limiting reductions between classification tasks"

costsensitive_WAP = WeightedAllPairs(svm.SVC(random_state=1), weigh_by_cost_diff=False)
costsensitive_WAP.fit(X_train, C_train)
preds_WAP = costsensitive_WAP.predict(X_test, method = 'most-wins')
f1_WAP = f1_score(y_test, preds_WAP, zero_division=1, average='weighted')
# log
collect_conf_mat.append(confusion_matrix(y_test, preds_WAP))
name_algorithm.append("Weighted All-Pairs SVM 'Error limiting reductions between classification tasks'")
f1_scores.append(f1_WAP)
costs.append(C_test[np.arange(C_test.shape[0]), preds_WAP].sum())


#### 2: WAP2 = Weighted All-Pairs - cost difference weights enabled

costsensitive_WAP2 = WeightedAllPairs(svm.SVC(random_state=1), weigh_by_cost_diff=True)
costsensitive_WAP2.fit(X_train, C_train)
preds_WAP2 = costsensitive_WAP2.predict(X_test)
f1_WAP2 = f1_score(y_test, preds_WAP2, zero_division=1, average='weighted')
# log
collect_conf_mat.append(confusion_matrix(y_test, preds_WAP2))
name_algorithm.append("Weighted All-Pairs SVM - cost difference weights enabled")
f1_scores.append(f1_WAP2)
costs.append( C_test[np.arange(C_test.shape[0]), preds_WAP2].sum() )


#### 3: WOR = Weighted One-Vs-Rest heuristic with simple cost-weighting schema

costsensitive_WOR = WeightedOneVsRest(svm.SVC(random_state=1), weight_simple_diff=True)
costsensitive_WOR.fit(X_train, C_train)
preds_WOR = costsensitive_WOR.predict(X_test)
f1_WOR = f1_score(y_test, preds_WOR, zero_division=1, average='weighted')
# log
collect_conf_mat.append(confusion_matrix(y_test, preds_WOR))
name_algorithm.append("Weighted One-Vs-Rest SVM, simple cost-weighting schema")
f1_scores.append(f1_WOR)
costs.append( C_test[np.arange(C_test.shape[0]), preds_WOR].sum() )

numplots = len(collect_conf_mat)
#print(numplots)
fig, ax = plt.subplots(numplots,1, sharey=True, figsize=(4,17))
#ax[0].get_shared_x_axes().join(ax[1])
for c in range(0,numplots):
    #ax[0].get_shared_x_axes().join(ax[c])
    sns.heatmap(collect_conf_mat[c], yticklabels=segment_names, annot=True, ax=ax[c], cmap=plt.cm.Blues, cbar=False)
    ax[c].set_title(name_algorithm[c],loc='center', fontsize=13)
    #plt.title(drop_combos[c], loc='center', fontsize=5)
    ax[numplots-1].set_xlabel("Predicted")
    ax[c].set_ylabel("True")
    ax[numplots-1].set_xticklabels(segment_names, fontsize=12, rotation=35, ha='right')
    
#fig.tight_layout(h_pad=2)
plt.subplots_adjust(hspace=0.3)
fig.suptitle('Confusion Matrix Comparison', fontsize = 22)
plt.subplots_adjust(top=0.9)
plt.show()

import pandas as pd

results = pd.DataFrame({
    'Method' : name_algorithm,
    'F1' : f1_scores,
    'Total_Cost' : costs
})
results=results[['Method', 'Total_Cost', 'F1']]
results.set_index('Method')

import matplotlib.pyplot as plt
import seaborn as sns
#%matplotlib inline

rank = results.F1.sort_values().index
palette = sns.color_palette('Blues', len(rank))


fig = plt.gcf()
fig.set_size_inches(11, 8)
sns.set(font_scale=1.3)
ax = sns.barplot(x = "F1", y = "Method", data = results, palette=np.array(palette)[rank])
ax.set(xlabel='log F1 (higher is better)')
# data bar annotations
for p in ax.patches:
    ax.annotate("%.4f" % p.get_width(), xy=(p.get_width(), p.get_y()+p.get_height()/2),
            xytext=(5, 0), textcoords='offset points', ha="left", va="center")
    
ax.set_xscale("log")
plt.title('Cost-Sensitive Classification - F1 Score metric', fontsize=20)
plt.show()

import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('dark')
#%matplotlib inline

rank = results['Total_Cost'].sort_values(ascending=False).index
palette = sns.color_palette('Blues', len(rank))

fig = plt.gcf()
fig.set_size_inches(11, 8)
sns.set(font_scale=1.3)
ax = sns.barplot(x = "Total_Cost", y = "Method", data = results, palette=np.array(palette)[rank])
ax.set(xlabel='Total Cost (lower is better)')
# data bar annotations
for p in ax.patches:
    ax.annotate("%.0f" % p.get_width(), xy=(p.get_width(), p.get_y()+p.get_height()/2),
            xytext=(5, 0), textcoords='offset points', ha="left", va="center")
    
plt.title('Cost-Sensitive Classification - Total Cost metric', fontsize=20)
plt.show()

results

results = results.assign(CostSavings = lambda x: (x['Total_Cost'] - results.loc[0,'Total_Cost']) * -1)
results = results.assign(F1_Deviation = lambda x: (x['F1'] - results.loc[0,'F1']))

results

import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('dark')
#%matplotlib inline

rank = results.iloc[1:,:]['CostSavings'].sort_values(ascending=True).index
rank2 = results.iloc[1:,:]['F1_Deviation'].sort_values(ascending=True).index
palette = sns.color_palette('Blues', len(rank))
palette2 = sns.color_palette('Reds', len(rank))

fig = plt.gcf()
fig.set_size_inches(11, 8)
sns.set(font_scale=1.3)
ax = sns.barplot(x = "CostSavings", y = "Method", data = results.iloc[1:,:], palette=np.array(palette)[rank-1])

ax.set(xlabel='Cost Savings (higher is better)')
ax2 = ax.twiny()
def change_width(ax, new_value) :
    locs = ax.get_yticks()
    for i,patch in enumerate(ax.patches):
        current_width = patch.get_width()
        diff = current_width - new_value
        # we change the bar width
        patch.set_height(new_value)
        # we recenter the bar
        patch.set_y(locs[i] - (new_value * .5))


ax2 = sns.barplot(x = "F1_Deviation", y = "Method", data = results.iloc[1:,:], palette=np.array(palette2)[rank2-1], ax=ax2)
ax2.set(xlabel='F1_Deviation (higher is better)')
change_width(ax2, .25)
   
plt.title('Comparison of Cost Sensitive Methods to the Baseline Model\n', fontsize=20)
plt.legend(['F1 Score Deviation', 'Cost Saving'], labelcolor=['crimson','royalblue'], loc='lower left', edgecolor='white')
plt.axvline(0, 0, color='crimson')
plt.show()