Sklearn Introduction

# mount notebook to drive
from google.colab import drive
drive.mount('/content/drive', force_remount=True)

# change dir to data folder
# data link: English - https://drive.google.com/file/d/1-_Bb3PavAML6HqoUJkpyg-zOb1bYZgWe/view?usp=sharing
# German - https://drive.google.com/file/d/1-KljKd9thoKEKdNnf6zZKDvmff8_NKUi/view?usp=sharing
# Vietnamese - https://drive.google.com/file/d/1-7A26XYVi1sbr3tmvlEqnH8SKuzMYMfM/view?usp=sharing
import os
os.chdir("drive/MyDrive/UTC/Intro_ML_Project/Assignment1/")

#require libray
import pandas as pd 
import numpy as np
import sklearn 
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn import svm
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, classification_report
import matplotlib.pyplot as plt
import seaborn as sns 
import plotly.express as px
import plotly.graph_objects as go
import warnings
warnings.filterwarnings('ignore')

#function to create data

def generate_data(filename, k_letter=5):
    #read files
    if filename != 'german.txt':
        f = open(filename)
        list_words = f.readlines()
    else:
        df_w = pd.read_csv(filename, encoding="ISO-8859-1", header=None)
        df_w = df_w.dropna()
        list_words = df_w.iloc[:,0].values
    #collect feature and label
    feature_dataset = []
    target_dataset = []
    for word in list_words:
        # Clean the line by removing the new-line character
        if filename != 'german.txt':
            cleaned_word = word.replace('\n', '')
        else:
            cleaned_word = word
        # Check if the length of the cleaned word is equal to 5, to get words with 5 characters.
        if len(cleaned_word) == k_letter:
            # Make an array for converting word to ord representation
            word_to_ord = []
            
            # Iterate through the cleaned word characters, ord the character, and append it to the word_to_ord list.
            for char in cleaned_word:
                word_to_ord.append(ord(char))
                
            # Append the ord'ed word to the training dataset
            feature_dataset.append(word_to_ord)
            
            # Append the correct answer to the target dataset
            if filename == "english.txt":
                target_dataset.append(0)
            elif filename == "german.txt":
                target_dataset.append(1)
            else:
                target_dataset.append(2)
    return np.array(feature_dataset), np.array(target_dataset)

# #generate english data
en_feat, en_target = generate_data("english.txt", k_letter=5)
#generate german data
gm_feat, gm_target = generate_data("german.txt", k_letter=5)
# #generate vietnamese data
vn_feat, vn_target = generate_data("vietnamese.txt", k_letter=5)
#combine as one data
all_feat = np.concatenate([en_feat, gm_feat,vn_feat], axis=0)
all_target = np.concatenate([en_target, gm_target,vn_target], axis=0)

#check shape of dataset 
print(en_feat.shape, gm_feat.shape, vn_feat.shape, all_feat.shape)
print(en_target.shape, gm_target.shape, vn_target.shape, all_target.shape)

#split train test
X_train, X_test, y_train, y_test = train_test_split(all_feat, all_target, test_size=0.2, random_state=42, shuffle=True, stratify=all_target)

#check shape data after split
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)

#KNN model
knn = KNeighborsClassifier(n_neighbors=4, metric='euclidean') #chose 3 of neighbors, euclidean metrix 
#training model
knn.fit(X_train, y_train)
#predict for test data
y_pred_knn = knn.predict(X_test)
#print accuracy on test_data
knn_acc = round(accuracy_score(y_test, y_pred_knn) * 100,1) 
print("Accuracy of KNN on test data: ", knn_acc)
#summary classification report
print(classification_report(y_test, y_pred_knn))

#SVN model
sv = svm.SVC(C=5.0, kernel='rbf') #chose kernel rbf
#training model
sv.fit(X_train, y_train)
#predict for test data
y_pred_svm = sv.predict(X_test)
#print accuracy on test_data
sv_acc = round(accuracy_score(y_test, y_pred_svm)*100,1)
print("Accuracy of SVM on test data: ", sv_acc)
#summary classification report
print(classification_report(y_test, y_pred_svm))

#MLP model
mlp = MLPClassifier(
    hidden_layer_sizes=(16,),
    activation = 'logistic',
    max_iter=100,
    alpha=1e-4,
    solver="sgd",
    verbose=10,
    random_state=42,
    learning_rate_init=0.02,
)   #chose kernel rbf
#training model
mlp.fit(X_train, y_train)
#predict for test data
y_pred_mlp = mlp.predict(X_test)
#print accuracy on test_data
mlp_acc = round(accuracy_score(y_test, y_pred_mlp)*100,1)
print("Accuracy of MLP on test data: ", mlp_acc)
#summary classification report
print(classification_report(y_test, y_pred_mlp))

#install kaleido library for save result
!pip install -U kaleido -q

# Label text for model
labels = ["KNN", "SVM", "MLP"]
# model results
results = [knn_acc, sv_acc, mlp_acc]
#create dataframe
df_results = pd.DataFrame.from_dict({"models": labels, "results": results})
fig = go.Figure()
#plot model 
fig.add_trace(go.Bar(
x=results,
y=labels,
marker=dict(
    color='rgba(50, 171, 96, 0.6)',
    line=dict(
        color='rgba(50, 171, 96, 1.0)',
        width=1),
),
orientation='h', text=results
))
#change postion of data label
fig.update_traces(textposition='outside')
# config charts
fig.update_layout(
    title='Machine Learning Models Comparison',
    xaxis_title="Accuracy",
    yaxis_title="Models",
    legend=dict(x=0.029, y=1.038, font_size=10),
    margin=dict(l=100, r=20, t=70, b=70),
    paper_bgcolor='rgb(248, 248, 255)',
    plot_bgcolor='rgb(248, 248, 255)',
    autosize=False,
    width=800,
    height=450,
)
# Display the graph
fig.show()
#save picture result
fig.write_image("models_result.png")