# A - K-Nearest Neighbors algorithm

# 1 - step : loading required libraries

import itertools

import inline as inline

import matplotlib

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.ticker import NullFormatter

import pandas as pd

import numpy as np

import matplotlib.ticker as ticker

from sklearn import preprocessing

%matplotlib inline

# 2 - step : URL of the dataset : !wget -O teleCust1000t.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/teleCust1000t.csv

# --> load data from cvs file

df = pd.read_csv('teleCust1000t.csv')

df.head()

# --> Data visualuzation and analysis

df['custcat'].value_counts()

df.hist(column='income', bins=50)

# feature set column

df.columns

# --> To use scikit-learn library, we have to convert the Pandas data frame to a Numpy array:

X = df[['region', 'tenure','age', 'marital', 'address', 'income', 'ed', 'employ','retire', 'gender', 'reside']] .values #.astype(float)

X[0:5]

# --> label

y = df['custcat'].values

y[0:5]

# step 3 : normalize data

X = preprocessing.StandardScaler().fit(X).transform(X.astype(float))

X[0:5]

# step 4 : Train test split

from sklearn.model_selection import train_test_split

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

print ('Train set:', X_train.shape, y_train.shape)

print ('Test set:', X_test.shape, y_test.shape)

# step 5 : Classification, K Nearest Neighbors (KNN), importing libraries

from sklearn.neighbors import KNeighborsClassifier

# step 6 : Training

k = 4

#Train Model and Predict

neigh = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)

neigh

# step 7 : predicting

yhat = neigh.predict(X_test)

yhat[0:5]

# step 8 : accuracy evaluation

from sklearn import metrics

print("Train set Accuracy: ", metrics.accuracy_score(y_train, neigh.predict(X_train)))

print("Test set Accuracy: ", metrics.accuracy_score(y_test, yhat))

# step 9 : calculate the accuracy of KNN

Ks = 10

mean_acc = np.zeros((Ks - 1))

std_acc = np.zeros((Ks - 1))

ConfustionMx = [];

for n in range(1, Ks):

# Train Model and Predict

neigh = KNeighborsClassifier(n_neighbors=n).fit(X_train, y_train)

yhat = neigh.predict(X_test)

mean_acc[n - 1] = metrics.accuracy_score(y_test, yhat)

std_acc[n - 1] = np.std(yhat == y_test) / np.sqrt(yhat.shape[0])

mean_acc

# --> plot model accuracy

plt.plot(range(1,Ks),mean_acc,'g')

plt.fill_between(range(1,Ks),mean_acc - 1 * std_acc,mean_acc + 1 * std_acc, alpha=0.10)

plt.legend(('Accuracy ', '+/- 3xstd'))

plt.ylabel('Accuracy ')

plt.xlabel('Number of Nabors (K)')

plt.tight_layout()

plt.show()

print( "The best accuracy was with", mean_acc.max(), "with k=", mean_acc.argmax()+1)

# Practice : for K = 6, accuracy = 52% and 31 (train set accuracy and test set accuracy) instead of 55% and 31 for K = 4

k = 6

neigh6 = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)

yhat6 = neigh6.predict(X_test)

print("Train set Accuracy: ", metrics.accuracy_score(y_train, neigh6.predict(X_train)))

print("Test set Accuracy: ", metrics.accuracy_score(y_test, yhat6))

# B - Decision Tree

# step 1 : import following libraries

import numpy as np

import pandas as pd

from sklearn.tree import DecisionTreeClassifier

# step 2 : downloading the data : !wget -O drug200.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/drug200.csv

# step 3 : reading data using Pandas data frame

my_data = pd.read_csv("drug200.csv", delimiter=",")

my_data[0:5]

# --> Pre-processing

X = my_data[['Age', 'Sex', 'BP', 'Cholesterol', 'Na_to_K']].values

X[0:5]

from sklearn import preprocessing

le_sex = preprocessing.LabelEncoder()

le_sex.fit(['F','M'])

X[:,1] = le_sex.transform(X[:,1])

le_BP = preprocessing.LabelEncoder()

le_BP.fit([ 'LOW', 'NORMAL', 'HIGH'])

X[:,2] = le_BP.transform(X[:,2])

le_Chol = preprocessing.LabelEncoder()

le_Chol.fit([ 'NORMAL', 'HIGH'])

X[:,3] = le_Chol.transform(X[:,3])

X[0:5]

y = my_data["Drug"]

y[0:5]

# --> setting up the decision tree

from sklearn.model_selection import train_test_split

X_trainset, X_testset, y_trainset, y_testset = train_test_split(X, y, test_size=0.3, random_state=3)

# step 4 : Modeling

drugTree = DecisionTreeClassifier(criterion="entropy", max_depth = 4)

drugTree # it shows the default parameters

drugTree.fit(X_trainset,y_trainset)

# stepa 5 : prediction

predTree = drugTree.predict(X_testset)

print (predTree [0:5])

print (y_testset [0:5])

# step 6 : Evaluation

from sklearn import metrics

import matplotlib.pyplot as plt

print("DecisionTrees's Accuracy: ", metrics.accuracy_score(y_testset, predTree))

# step 7 : Visualization

from sklearn.externals.six import StringIO

import pydotplus

import matplotlib.image as mpimg

from sklearn import tree

%matplotlib inline

dot_data = StringIO()

filename = "drugtree.png"

featureNames = my_data.columns[0:5]

targetNames = my_data["Drug"].unique().tolist()

out=tree.export_graphviz(drugTree,feature_names=featureNames, out_file=dot_data, class_names= np.unique(y_trainset), filled=True, special_characters=True,rotate=False)

graph = pydotplus.graph_from_dot_data(dot_data.getvalue())

graph.write_png(filename)

img = mpimg.imread(filename)

plt.figure(figsize=(100, 200))

plt.imshow(img,interpolation='nearest')

# C - Logistic Regression

# step 1 : import the libraries

import pandas as pd

import pylab as pl

import numpy as np

import scipy.optimize as opt

from sklearn import preprocessing

%matplotlib inline

import matplotlib.pyplot as plt

# step 2 : load data : To download the data, we will use !wget to download it from IBM Object Storage.

#Click here and press Shift+Enter

# URL : !wget -O ChurnData.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/ChurnData.csv

# step 3 : Load data from csv file

churn_df = pd.read_csv("ChurnData.csv")

churn_df.head()

# --> Data pre-processing and selection

churn_df = churn_df[['tenure', 'age', 'address', 'income', 'ed', 'employ', 'equip', 'callcard', 'wireless','churn']]

churn_df['churn'] = churn_df['churn'].astype('int')

churn_df.head()

# --> define X and Y for our dataset

X = np.asarray(churn_df[['tenure', 'age', 'address', 'income', 'ed', 'employ', 'equip']])

X[0:5]

y = np.asarray(churn_df['churn'])

y [0:5]

# --> Normalize the dataset

from sklearn import preprocessing

X = preprocessing.StandardScaler().fit(X).transform(X)

X[0:5]

# step 4 : Train/Test dataset

from sklearn.model_selection import train_test_split

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

print ('Train set:', X_train.shape, y_train.shape)

print ('Test set:', X_test.shape, y_test.shape)

# Modeling with Sciekit Learning

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import confusion_matrix

LR = LogisticRegression(C=0.01, solver='liblinear').fit(X_train,y_train)

LR

# step 5 : prediction Test set

yhat = LR.predict(X_test)

yhat

# --> calculate probability

yhat_prob = LR.predict_proba(X_test)

yhat_prob

# step 6 : Evaluation with Jaccard index

from sklearn.metrics import jaccard_similarity_score

jaccard_similarity_score(y_test, yhat)

# --> confusion matrix :

from sklearn.metrics import classification_report, confusion_matrix

import itertools

def plot_confusion_matrix(cm, classes,

plt.xlabel('Predicted label')

print(confusion_matrix(y_test, yhat, labels=[1,0]))

# --> plot confusion matrix to know True Positive, True Negative, False Positive and False Negative.

# Compute confusion matrix

cnf_matrix = confusion_matrix(y_test, yhat, labels=[1,0])

np.set_printoptions(precision=2)

# Plot non-normalized confusion matrix

plt.figure()

plot_confusion_matrix(cnf_matrix, classes=['churn=1','churn=0'],normalize= False, title='Confusion matrix')

print (classification_report(y_test, yhat)) # ==> Precision (accuracy) = TP/(Tp+FP) || Recall (true positive rate) = TP/(TP+FN)

# step 7 : log loss

from sklearn.metrics import log_loss

log_loss(y_test, yhat_prob)

# --> Or we can reach log loss value by using logistic regression model

LR2 = LogisticRegression(C=0.01, solver='sag').fit(X_train, y_train)

yhat_prob2 = LR2.predict_proba(X_test)

print("LogLoss: : %.2f" % log_loss(y_test, yhat_prob2))

# D - Support Vector Machines (SVM)

# step 1 : Import the libraries

import pandas as pd

import pylab as pl

import numpy as np

import scipy.optimize as opt

from sklearn import preprocessing

from sklearn.model_selection import train_test_split

%matplotlib inline

import matplotlib.pyplot as plt

# step 2 : Load data ==> #Click here and press Shift+Enter

# !wget -O cell_samples.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/cell_samples.csv

# Load data from CSV file

cell_df = pd.read_csv("cell_samples.csv")

cell_df.head()

# distribution of the class

ax = cell_df[cell_df['Class'] == 4][0:50].plot(kind='scatter', x='Clump', y='UnifSize', color='DarkBlue', label='malignant');

cell_df[cell_df['Class'] == 2][0:50].plot(kind='scatter', x='Clump', y='UnifSize', color='Yellow', label='benign', ax=ax);

plt.show()

# --> Pre-processing and selection

# 1

cell_df.dtypes

# 2

cell_df = cell_df[pd.to_numeric(cell_df['BareNuc'], errors='coerce').notnull()]

cell_df['BareNuc'] = cell_df['BareNuc'].astype('int')

cell_df.dtypes

# 3

feature_df = cell_df[['Clump', 'UnifSize', 'UnifShape', 'MargAdh', 'SingEpiSize', 'BareNuc', 'BlandChrom', 'NormNucl', 'Mit']]

X = np.asarray(feature_df)

X[0:5]

# --> Predict value of class

cell_df['Class'] = cell_df['Class'].astype('int')

y = np.asarray(cell_df['Class'])

y [0:5]

# step 3 Train/test dataset

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

print ('Train set:', X_train.shape, y_train.shape)

print ('Test set:', X_test.shape, y_test.shape)

# step 4 : Modeling SVM in Sciekit Leraning : can choise between

# 1.Linear

# 2.Polynomial

# 3.Radial basis function (RBF)

# 4.Sigmoid

from sklearn import svm

clf = svm.SVC(kernel='rbf')

clf.fit(X_train, y_train)

# step 6 : predict new value

yhat = clf.predict(X_test)

yhat [0:5]

# step 7 : Evaluation

from sklearn.metrics import classification_report, confusion_matrix

import itertools

def plot_confusion_matrix(cm, classes,

plot_confusion_matrix(cnf_matrix, classes=['Benign(2)', 'Malignant(4)'], normalize=False, title='Confusion matrix')

# --> f1-score from Sciekit Learning

from sklearn.metrics import f1_score

f1_score(y_test, yhat, average='weighted')

# --> Jaccard index for accuracy

from sklearn.metrics import jaccard_similarity_score

jaccard_similarity_score(y_test, yhat)

# what change can new kernel function come in

clf2 = svm.SVC(kernel='linear')

clf2.fit(X_train, y_train)

yhat2 = clf2.predict(X_test)

print("Avg F1-score: %.4f" % f1_score(y_test, yhat2, average='weighted'))

print("Jaccard score: %.4f" % jaccard_similarity_score(y_test, yhat2))