Learn From Scratch Neural Networks Using PyQt: Part 4

This content is powered by Balige Publishing. Visit this link (collaboration with Rismon Hasiholan Sianipar) PART 1 PART 2 PART 3

In this tutorial, you will learn how to use Pandas, NumPy, Scikit-Learn, and other libraries to perform simple classification using perceptron and Adaline (adaptive linear neuron). The dataset used is Iris dataset directly from the UCI Machine Learning Repository.

Tutorial Steps To Implement Logistic Regression Model Using Scikit-Learn with PyQt

Step 1: In this tutorial, you will use the from sklearn.linear_model class as well as the familiar fit() method to train the model on all three classes in the standardized flower training dataset:

#LogisticRegression_Scikit_ex.py
from sklearn import datasets
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import make_pipeline
from sklearn.metrics import accuracy_score
from matplotlib.colors import ListedColormap
import matplotlib.pyplot as plt

def plot_classifier(X, y, classifier, test_idx=None, resolution=0.01):
    # setup marker generator and color map
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])
    
    # plot the decision surface
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
                           np.arange(x2_min, x2_max, resolution))
    
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    
    plt.contourf(xx1, xx2, Z, alpha=0.5, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],
                    alpha=0.8, c=colors[idx],
                    marker=markers[idx], label=cl,
                    edgecolor='black')        
    # highlight test samples
    if test_idx:
        # plot all samples
        X_test, y_test = X[test_idx, :], y[test_idx]
        plt.scatter(X_test[:, 0], X_test[:, 1],
                    c='', edgecolor='black', alpha=1.0,
                    linewidth=1, marker='o',
                    s=100, label='test set')
        
#Load data into matrix X and vector y
iris = datasets.load_iris()
X = iris.data[:, [2, 3]]
y = iris.target
print('Class labels:', np.unique(y))
#print(X)

# plot data       
plt.scatter(X[:50, 0], X[:50, 1],
            color='red', marker='o', label='setosa')
plt.scatter(X[50:100, 0], X[50:100, 1],
            color='blue', marker='x', label='versicolor')
plt.scatter(X[100:150, 0], X[100:150, 1],
            color='green', marker='x', label='versicolor')
plt.xlabel('petal length [cm]')
plt.ylabel('petal width [cm]')
plt.legend(loc='upper left')
plt.show()

#Splits the dataset into separate training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1, stratify=y)

#standardizes the features using the StandardScaler 
sc = StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)

#Trains logistic regression model
lgr = make_pipeline(StandardScaler(), SGDClassifier('log',max_iter=1000,eta0=0.01, tol=1e-3))
lgr.fit(X_train_std, y_train)

#Makes prediction
y_pred = lgr.predict(X_test_std)
print('Misclassified samples: %d' % (y_test != y_pred).sum())

#Calculates classification accuracy 
print('Accuracy: %.2f' % accuracy_score(y_test, y_pred))

X_combined_std = np.vstack((X_train_std, X_test_std))
y_combined = np.hstack((y_train, y_test))

plot_classifier(X_combined_std, y_combined, classifier=lgr)
plt.xlabel('petal length [standardized]')
plt.ylabel('petal width [standardized]')
plt.legend(loc='upper left')
plt.show()

Step 2: Run the script to see decision regions as shown in Figure below.

Step 3: Open gui_scikit.ui form that you created before. Modify listAlgorithm widget, so that it only has two items as shown in Figure below.

Step 4: Add these two import statements:

from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import make_pipeline

Step 5: Disable listAlgorithm widget when form first runs as shown in line 13. Connect clicked() signal of the widget with algo_NN() function and initially select its first row. Put them inside __init__() method as follows:

def __init__(self):       
    QMainWindow.__init__(self)
    loadUi("gui_scikit.ui",self)

    self.setWindowTitle("GUI Demo of Classifier Using Scikit-Learn")
    self.addToolBar(NavigationToolbar(self.widgetData.canvas, self))
    self.gbNNParam.setEnabled(False)
    self.listAlgorithm.setEnabled(False)
    self.pbLoad.clicked.connect(self.load_data)
    self.sbIter.valueChanged.connect(self.algo_NN)
    self.dsbRate.valueChanged.connect(self.algo_NN)
    self.dsbRatio.valueChanged.connect(self.algo_NN)    
    self.listAlgorithm.setEnabled(False)
    self.listAlgorithm.clicked.connect(self.algo_NN)
    self.listAlgorithm.setCurrentRow(0)

Step 6: Enable listAlgorithm widget after user clicks Load Data button:

def load_data(self):
    #Load data into matrix X and vector y
    iris = datasets.load_iris()
    self.X = iris.data[:, [2, 3]]
    self.y = iris.target   
    self.display_data(self.X, self.widgetData.canvas)
        
    self.gbNNParam.setEnabled(True)
    self.pbLoad.setEnabled(False)  
    self.listAlgorithm.setEnabled(True)

Step 7: Modify algo_NN() function so that it reads the text of selected item in listAlgorithm widget to determine action accordingly:

def algo_NN(self): 
    iterNum = self.sbIter.value()
    ratio = self.dsbRatio.value()
    self.dsbRate.setDecimals(5)
    learningRate = self.dsbRate.value()
        
    #Splits the dataset into separate training and test datasets
    X_train, X_test, y_train, y_test = train_test_split(self.X, \
        self.y, test_size=ratio, random_state=1, stratify=self.y)
        
    #standardizes the features using the StandardScaler 
    sc = StandardScaler()
    sc.fit(X_train)
    X_train_std = sc.transform(X_train)
    X_test_std = sc.transform(X_test)

    item = self.listAlgorithm.currentItem()
    strList = item.text()
        
    if strList == 'Perceptron':
        #Trains perceptron
        ppn = Perceptron(max_iter=iterNum, eta0=learningRate, \
            random_state=1)
        ppn.fit(X_train_std, y_train)
        
        X_combined_std = np.vstack((X_train_std, X_test_std))
        y_combined = np.hstack((y_train, y_test))
        
        strTitle = 'Perceptron Classifier with ' +\
            str(ratio*100) + '% Data Ratio '
        strTitle += ' and Learning Rate ' +str(learningRate)
        
        self.display_decision(X=X_combined_std, y=y_combined, \
            classifier=ppn, axisWidget=self.widgetDecision.canvas, \
            title=strTitle, test_idx=range(105, 150))
        
        #display graph
        self.graph(self.widgetEpoch.canvas, self.accuracy_perceptron)

Step 8: Add this code to algo_NN() function so that when user choose Logistic Regression from listAlgorithm widget, it will perform logistic regression classification:

if strList == 'Logistic Regression':
    #Trains logistic regression model
    lgr = make_pipeline(StandardScaler(), \
        SGDClassifier(max_iter=iterNum,eta0=learningRate, \
        tol=1e-3))
    lgr.fit(X_train_std, y_train)
            
    X_combined_std = np.vstack((X_train_std, X_test_std))
    y_combined = np.hstack((y_train, y_test))
            
    strTitle = 'Logistic Regression Classifier with ' + \
        str(ratio*100) + '% Data Ratio '
        
    self.display_decision(X=X_combined_std, y=y_combined, \
        classifier=lgr, axisWidget=self.widgetDecision.canvas, \
        title=strTitle, test_idx=range(105, 150))
                
    #display graph
    self.graph(self.widgetEpoch.canvas, self.accuracy_logistic)

Step 9: Define accuracy_logistic() to calculate accuracy of logistic regression model:

def accuracy_logistic(self,ratio,learningRate):        
    #Splits the dataset into separate training and test datasets
    X_train, X_test, y_train, y_test = train_test_split(self.X,\
        self.y, test_size=ratio, random_state=1, stratify=self.y)
        
    #standardizes the features using the StandardScaler 
    sc = StandardScaler()
    sc.fit(X_train)
    X_train_std = sc.transform(X_train)
    X_test_std = sc.transform(X_test)
        
    #Trains logistic regression model
    lgr = make_pipeline(StandardScaler(), \
        SGDClassifier('log',max_iter=1000,eta0=learningRate, \
        tol=1e-3))
    lgr.fit(X_train_std, y_train)
                
    #Makes prediction
    y_pred = lgr.predict(X_test_std)

    #Calculates classification accuracy 
    acc = round(100*accuracy_score(y_test, y_pred),1)
    return acc 

Step 10: Run Scikit_Classifier.py and choose Logistic Regression from list widget to see the result as shown in Figure below. 

Then choose data ratio 0.5 and learning rate 0.05. The result is shown in Figure below.

Below is the full script of Scikit_Classifier.py so far:

#Scikit_Classifier.py
from PyQt5.QtWidgets import *
from PyQt5.uic import loadUi
from matplotlib.backends.backend_qt5agg import (NavigationToolbar2QT as NavigationToolbar)
from matplotlib.colors import ListedColormap
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Perceptron
from sklearn.metrics import accuracy_score
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import make_pipeline
import numpy as np
import pandas as pd 

class DemoGUIScikit(QMainWindow):   
    def __init__(self):       
        QMainWindow.__init__(self)
        loadUi("gui_scikit.ui",self)

        self.setWindowTitle("GUI Demo of Classifier Using Scikit-Learn")
        self.addToolBar(NavigationToolbar(self.widgetData.canvas, self))
        self.gbNNParam.setEnabled(False)
        self.listAlgorithm.setEnabled(False)
        self.pbLoad.clicked.connect(self.load_data)
        self.sbIter.valueChanged.connect(self.algo_NN)
        self.dsbRate.valueChanged.connect(self.algo_NN)
        self.dsbRatio.valueChanged.connect(self.algo_NN)    
        self.listAlgorithm.setEnabled(False)
        self.listAlgorithm.clicked.connect(self.algo_NN)
        self.listAlgorithm.setCurrentRow(0)
        
    def load_data(self):
        #Load data into matrix X and vector y
        iris = datasets.load_iris()
        self.X = iris.data[:, [2, 3]]
        self.y = iris.target   
        self.display_data(self.X, self.widgetData.canvas)
        
        self.gbNNParam.setEnabled(True)
        self.pbLoad.setEnabled(False)  
        self.listAlgorithm.setEnabled(True)               

    def display_data(self,X,axisWidget):             
        # plot data
        axisWidget.axis1.clear()
        axisWidget.axis1.scatter(X[:50, 0], X[:50, 1],
            color='red', marker='o', label='setosa')
        
        axisWidget.axis1.scatter(X[50:100, 0], X[50:100, 1],
            color='blue', marker='x', label='versicolor')
        
        axisWidget.axis1.scatter(X[100:150, 0], X[100:150, 1],
            color='green', marker='x', label='virginica')
        
        axisWidget.axis1.set_xlabel('Petal length [cm]')
        axisWidget.axis1.set_ylabel('petal Width [cm]')
        axisWidget.axis1.legend(loc='upper left')
        
        title = 'Petal length and Petal width [cm]'
        axisWidget.axis1.set_title(title)
        axisWidget.draw()
                
        #displays data on table widget
        self.display_table()

        #Displays decision regions       
        self.algo_NN()        

    def display_table(self):
        data = datasets.load_iris()
        df = pd.DataFrame(np.column_stack((data.data, data.target)), \
            columns = data.feature_names+['target'])
        df['label'] = df.target.replace(dict(enumerate(data.target_names)))

        # show data on table widget
        self.write_df_to_qtable(df,self.tableData)
        self.tableData.setHorizontalHeaderLabels(data.feature_names)
        
        styleH = "::section {""background-color: cyan; }"
        self.tableData.horizontalHeader().setStyleSheet(styleH)

        styleV = "::section {""background-color: red; }"
        self.tableData.verticalHeader().setStyleSheet(styleV)  

    # Takes a df and writes it to a qtable provided. df headers become qtable headers
    @staticmethod
    def write_df_to_qtable(df,table):
        table.setRowCount(df.shape[0])
        table.setColumnCount(df.shape[1])       

        # getting data from df is computationally costly so convert it to array first
        df_array = df.values
        for row in range(df.shape[0]):
            for col in range(df.shape[1]):
                table.setItem(row, col, QTableWidgetItem(str(df_array[row,col])))


    def display_decision(self, X, y, classifier, axisWidget, title, \
        test_idx=None, resolution=0.01):
        # setup marker generator and color map
        markers = ('s', 'x', 'o', '^', 'v')
        colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
        cmap = ListedColormap(colors[:len(np.unique(y))])
    
        # plot the decision surface
        x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
        x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
        xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
                           np.arange(x2_min, x2_max, resolution))
    
        Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
        Z = Z.reshape(xx1.shape)
        axisWidget.axis1.clear()
        axisWidget.axis1.contourf(xx1, xx2, Z, alpha=0.5, cmap=cmap)
        axisWidget.axis1.set_xlim(xx1.min(), xx1.max())
        axisWidget.axis1.set_ylim(xx2.min(), xx2.max())

        for idx, cl in enumerate(np.unique(y)):
            axisWidget.axis1.scatter(x=X[y == cl, 0], y=X[y == cl, 1],
                    alpha=0.8, c=colors[idx],
                    marker=markers[idx], label=cl,
                    edgecolor='black')
        
        # highlight test samples
        if test_idx:
            # plot all samples
            X_test, y_test = X[test_idx, :], y[test_idx]
            axisWidget.axis1.scatter(X_test[:, 0], X_test[:, 1],
                    c='', edgecolor='black', alpha=1.0,
                    linewidth=1, marker='o',
                    s=100, label='test set')
        
        axisWidget.axis1.set_xlabel('petal length [standardized]')
        axisWidget.axis1.set_ylabel('petal width [standardized]')
        axisWidget.axis1.set_label('petal width [standardized]')
        axisWidget.axis1.legend(loc='upper left')
        axisWidget.axis1.set_title(title)
        axisWidget.draw()

    def algo_NN(self): 
        iterNum = self.sbIter.value()
        ratio = self.dsbRatio.value()
        self.dsbRate.setDecimals(5)
        learningRate = self.dsbRate.value()
        
        #Splits the dataset into separate training and test datasets
        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, \
            test_size=ratio, random_state=1, stratify=self.y)
        
        #standardizes the features using the StandardScaler 
        sc = StandardScaler()
        sc.fit(X_train)
        X_train_std = sc.transform(X_train)
        X_test_std = sc.transform(X_test)

        item = self.listAlgorithm.currentItem()
        strList = item.text()
        
        if strList == 'Perceptron':
            #Trains perceptron
            ppn = Perceptron(max_iter=iterNum, eta0=learningRate, \
                random_state=1)
            ppn.fit(X_train_std, y_train)
        
            X_combined_std = np.vstack((X_train_std, X_test_std))
            y_combined = np.hstack((y_train, y_test))
        
            strTitle = 'Perceptron Classifier with ' + str(ratio*100) + '% Data Ratio '
            strTitle += ' and Learning Rate ' +str(learningRate)
        
            self.display_decision(X=X_combined_std, y=y_combined, \
                classifier=ppn, axisWidget=self.widgetDecision.canvas, \
                title=strTitle, test_idx=range(105, 150))
        
            #display graph
            self.graph(self.widgetEpoch.canvas, self.accuracy_perceptron)

        if strList == 'Logistic Regression':
            #Trains logistic regression model
            lgr = make_pipeline(StandardScaler(), \
                SGDClassifier(max_iter=iterNum,eta0=learningRate, tol=1e-3))
            #lgr = LogisticRegression(C=100.0, random_state=1)
            lgr.fit(X_train_std, y_train)
            
            X_combined_std = np.vstack((X_train_std, X_test_std))
            y_combined = np.hstack((y_train, y_test))
            
            strTitle = 'Logistic Regression Classifier with ' + str(ratio*100) + '% Data Ratio '
        
            self.display_decision(X=X_combined_std, y=y_combined, \
                classifier=lgr, axisWidget=self.widgetDecision.canvas, \
                title=strTitle, test_idx=range(105, 150))
                
            #display graph
            self.graph(self.widgetEpoch.canvas, self.accuracy_logistic)
    
    def accuracy_perceptron(self,ratio,learningRate):        
        #Splits the dataset into separate training and test datasets
        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, \
            test_size=ratio, random_state=1, stratify=self.y)
        
        #standardizes the features using the StandardScaler 
        sc = StandardScaler()
        sc.fit(X_train)
        X_train_std = sc.transform(X_train)
        X_test_std = sc.transform(X_test)
        
        #Trains perceptron
        ppn = Perceptron(max_iter=100, eta0=learningRate, random_state=1)
        ppn.fit(X_train_std, y_train)
                
        #Makes prediction
        y_pred = ppn.predict(X_test_std)

        #Calculates classification accuracy 
        acc = round(100*accuracy_score(y_test, y_pred),1)
        return acc

    def accuracy_logistic(self,ratio,learningRate):        
        #Splits the dataset into separate training and test datasets
        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, \
            test_size=ratio, random_state=1, stratify=self.y)
        
        #standardizes the features using the StandardScaler 
        sc = StandardScaler()
        sc.fit(X_train)
        X_train_std = sc.transform(X_train)
        X_test_std = sc.transform(X_test)
        
        #Trains logistic regression model
        lgr = make_pipeline(StandardScaler(), \
            SGDClassifier('log',max_iter=1000,eta0=learningRate, tol=1e-3))
        lgr.fit(X_train_std, y_train)
                
        #Makes prediction
        y_pred = lgr.predict(X_test_std)

        #Calculates classification accuracy 
        acc = round(100*accuracy_score(y_test, y_pred),1)
        return acc          
            
    def graph(self,axisWidget,func): 
        ratio = self.dsbRatio.value()
        learningRate = self.dsbRate.value()
        
        if (ratio+0.4) < 1 :
            rangeDR = [ratio,ratio+0.1,ratio+0.2,ratio+0.3,ratio+0.4]
        else :
           rangeDR = [ratio-0.4,ratio-0.3,ratio-0.2,ratio-0.1,ratio]     

        labels = [str(round(rangeDR[0],2)), str(round(rangeDR[1],2)), \
                  str(round(rangeDR[2],2)), str(round(rangeDR[3],2)), \
                  str(round(rangeDR[4],2))]
               
        LR01 = []
        for i in rangeDR:
            acc = func(i,learningRate)
            LR01.append(acc)   

        LR001 = []
        for i in rangeDR:
            acc = func(i,learningRate+0.1)
            LR001.append(acc)  
            
        LR0001 = []
        for i in rangeDR:
            acc = func(i,learningRate+0.25)
            LR0001.append(acc)       
            
        x = np.arange(len(labels))  # the label locations
        width = 0.3  # the width of the bars
        
        strLabel1 = 'LR=' + str(round(learningRate, 2))
        strLabel2 = 'LR=' + str(round(learningRate+0.1, 2))
        strLabel3 = 'LR=' + str(round(learningRate+0.25, 2))
        axisWidget.axis1.clear()
        rects1 = axisWidget.axis1.bar(x - width/2, LR01, width, label=strLabel1)
        rects2 = axisWidget.axis1.bar(x + width/2, LR001, width, \
            label=strLabel2)
        rects3 = axisWidget.axis1.bar(x + 3*width/2, LR0001, width, \
            label=strLabel3)

        # Add some text for labels, title and custom x-axis tick labels, etc.
        axisWidget.axis1.set_ylabel('Accuracy(%)')
        axisWidget.axis1.set_xlabel('Data Ratio (DR)')
        axisWidget.axis1.set_title('Accuracy by data ratio (DR) and learning rate (LR)')
        axisWidget.axis1.set_xticks(x)
        axisWidget.axis1.set_xticklabels(labels)
        axisWidget.axis1.legend()
        #axisWidget.axis1.set_facecolor('xkcd:banana')
        
        self.autolabel(rects1,axisWidget.axis1)
        self.autolabel(rects2,axisWidget.axis1)
        self.autolabel(rects3,axisWidget.axis1)
        axisWidget.draw()

    def autolabel(self,rects,axisWidget):
        """Attach a text label above each bar in *rects*, displaying its height."""
        for rect in rects:
            height = rect.get_height()
            axisWidget.annotate('{}'.format(height),
                    xy=(rect.get_x() + rect.get_width() / 2, height),
                    xytext=(0, 3),  # 3 points vertical offset
                    textcoords="offset points",
                    ha='center', va='bottom')
              
if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)
    ex = DemoGUIScikit()
    ex.show()
    sys.exit(app.exec_())

Learn From Scratch Neural Networks Using PyQt: Part 5