Learn From Scratch Neural Networks Using PyQt: Part 6

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

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 Decision Tree (DT) Using Scikit-Learn
Step 1: In this tutorial, you will use the from sklearn.tree class as well as the familiar fit() method to train the model on all three classes in the dataset:

#DT_Scikit_ex.py
from sklearn import datasets
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
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)

#Trains Decision Tree model
tree = DecisionTreeClassifier(criterion='gini', max_depth=4,random_state=1)            
tree.fit(X_train, y_train)
            
X_combined = np.vstack((X_train, X_test))
y_combined = np.hstack((y_train, y_test))

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

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

plot_classifier(X_combined, y_combined, classifier=tree)
plt.xlabel('petal length')
plt.ylabel('petal width')
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 has the fourth item as shown in Figure below.

Step 4: Add a new Spin Box widget onto form and set its objectName property as sbDepth. Set its minimum, maximum, singleStep, and value properties to 2, 10, 1, and 4. 

The newly modified form now looks as shown in Figure below.

Step 5: Add this import statement into Scikit_Classifier.py:

from sklearn.tree import DecisionTreeClassifier

Step 6: Add this code to the top side of algo_NN() function to enable sbIter and dsbRate widgets and to disable sbDepth widget:

self.sbIter.setEnabled(True)  
self.dsbRate.setEnabled(True)  
self.sbDepth.setEnabled(False) 

depth = self.sbDepth.value()

Step 7: Add this code to algo_NN() function so that when user choose Decision Tree from listAlgorithm widget, it will perform DT classification:

if strList == 'Decision Tree':
    self.sbIter.setEnabled(False)  
    self.dsbRate.setEnabled(False)  
    self.sbDepth.setEnabled(True) 
            
    #Trains Decision Tree model
    tree = DecisionTreeClassifier(criterion='gini', \
        max_depth=depth,random_state=1)            
    tree.fit(X_train, y_train)
            
    X_combined = np.vstack((X_train, X_test))
    y_combined = np.hstack((y_train, y_test))
            
    strTitle = 'Decision Tree Classifier with ' + \
        str(ratio*100) + '% Data Ratio '
    strTitle += ' and Max Depth ' +str(depth)
    self.display_decision(X=X_combined, y=y_combined, \
        classifier=tree, axisWidget=self.widgetDecision.canvas, \
        title=strTitle, test_idx=range(105, 150)) 
                
    #display accuracy graph
    self.graph_dt(self.widgetEpoch.canvas, self.accuracy_dt)

Step 8: Define accuracy_dt() to calculate accuracy of DT model:

def accuracy_dt(self,ratio,depth):        
    #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)
        
    #Trains Decision Tree model
    tree = DecisionTreeClassifier(criterion='gini', \
        max_depth=depth,random_state=1)            
    tree.fit(X_train, y_train)
                            
    #Makes prediction
    y_pred = tree.predict(X_test)
        
    #Calculates classification accuracy 
    acc = round(100*accuracy_score(y_test, y_pred),1)
    return acc 

Step 9: Define graph_dt() function to draw accuracy plot of data ratio versus max depth:

def graph_dt(self,axisWidget,func): 
    ratio = self.dsbRatio.value()
    depth = self.sbDepth.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))]               
    Depth1 = []
    for i in rangeDR:
        acc = func(i,depth)
        Depth1.append(acc)   
    Depth2 = []
    for i in rangeDR:
        acc = func(i,depth+4)
        Depth2.append(acc)             
    Depth3 = []
    for i in rangeDR:
        acc = func(i,depth+4)
        Depth3.append(acc)       
            
    x = np.arange(len(labels))  # the label locations
    width = 0.3  # the width of the bars
        
    strLabel1 = 'Depth=' + str(round(depth, 2))
    strLabel2 = 'Depth=' + str(round(depth+2, 2))
    strLabel3 = 'Depth=' + str(round(depth+4, 2))
    axisWidget.axis1.clear()
    rects1 = axisWidget.axis1.bar(x - width/2, Depth1, \
        width, label=strLabel1)
    rects2 = axisWidget.axis1.bar(x + width/2, Depth2, \
        width, label=strLabel2)
    rects3 = axisWidget.axis1.bar(x + 3*width/2, Depth3, \
        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 Depth')
    axisWidget.axis1.set_xticks(x)
    axisWidget.axis1.set_xticklabels(labels)
    axisWidget.axis1.legend()        
    self.autolabel(rects1,axisWidget.axis1)
    self.autolabel(rects2,axisWidget.axis1)
    self.autolabel(rects3,axisWidget.axis1)
    axisWidget.draw()

Step 10: Connect valueChanged() of sbDepth widget to algo_NN() function and put it inside __init__() method:

self.sbDepth.valueChanged.connect(self.algo_NN)

Step 11: Run Scikit_Classifier.py, choose Decision Tree (DT) from list widget, and set data ratio 0.3 and max depth 4 to see the result as shown in Figure below.

Then choose data ratio 0.5 and max depth 3. 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
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
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)
        self.sbDepth.valueChanged.connect(self.algo_NN)
        self.sbNeighbor.valueChanged.connect(self.algo_NN)
        
    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): 
        self.sbIter.setEnabled(True)  
        self.dsbRate.setEnabled(True)  
        self.sbDepth.setEnabled(False) 
        self.sbNeighbor.setEnabled(False)
        
        iterNum = self.sbIter.value()
        ratio = self.dsbRatio.value()
        self.dsbRate.setDecimals(5)
        learningRate = self.dsbRate.value()
        depth = self.sbDepth.value()
        neighbor = self.sbDepth.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('log',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)

        if strList == 'Support Vector Machine (SVM)':
            #Trains SVM model
            svm = make_pipeline(StandardScaler(), SGDClassifier('hinge',max_iter=iterNum,eta0=learningRate, tol=1e-3))
            svm.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 = 'SVM Classifier with ' + str(ratio*100) + '% Data Ratio '
        
            self.display_decision(X=X_combined_std, y=y_combined, classifier=svm, \
                              axisWidget=self.widgetDecision.canvas, \
                              title=strTitle, test_idx=range(105, 150))
                
            #display graph
            self.graph(self.widgetEpoch.canvas, self.accuracy_svm)
        
        if strList == 'Decision Tree':
            self.sbIter.setEnabled(False)  
            self.dsbRate.setEnabled(False)  
            self.sbDepth.setEnabled(True) 
            
            #Trains Decision Tree model
            tree = DecisionTreeClassifier(criterion='gini', max_depth=depth,random_state=1)            
            tree.fit(X_train, y_train)
            
            X_combined = np.vstack((X_train, X_test))
            y_combined = np.hstack((y_train, y_test))
            
            strTitle = 'Decision Tree Classifier with ' + str(ratio*100) + '% Data Ratio '
            strTitle += ' and Max Depth ' +str(depth)
            self.display_decision(X=X_combined, y=y_combined, classifier=tree, \
                              axisWidget=self.widgetDecision.canvas, \
                              title=strTitle, test_idx=range(105, 150)) 
                
            #display accuracy graph
            self.graph_dt(self.widgetEpoch.canvas, self.accuracy_dt)

    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 accuracy_svm(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
        svm = make_pipeline(StandardScaler(), SGDClassifier('hinge',max_iter=1000,eta0=learningRate, tol=1e-3))
        svm.fit(X_train_std, y_train)
                
        #Makes prediction
        y_pred = svm.predict(X_test_std)

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

    def accuracy_dt(self,ratio,depth):        
        #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)
        
        #Trains Decision Tree model
        tree = DecisionTreeClassifier(criterion='gini', max_depth=depth,random_state=1)            
        tree.fit(X_train, y_train)
                            
        #Makes prediction
        y_pred = tree.predict(X_test)
        
        #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')


    def graph_dt(self,axisWidget,func): 
        ratio = self.dsbRatio.value()
        depth = self.sbDepth.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))]
               
        Depth1 = []
        for i in rangeDR:
            acc = func(i,depth)
            Depth1.append(acc)   

        Depth2 = []
        for i in rangeDR:
            acc = func(i,depth+4)
            Depth2.append(acc)  
            
        Depth3 = []
        for i in rangeDR:
            acc = func(i,depth+4)
            Depth3.append(acc)       
            
        x = np.arange(len(labels))  # the label locations
        width = 0.3  # the width of the bars
        
        strLabel1 = 'Depth=' + str(round(depth, 2))
        strLabel2 = 'Depth=' + str(round(depth+2, 2))
        strLabel3 = 'Depth=' + str(round(depth+4, 2))
        axisWidget.axis1.clear()
        rects1 = axisWidget.axis1.bar(x - width/2, Depth1, width, label=strLabel1)
        rects2 = axisWidget.axis1.bar(x + width/2, Depth2, width, label=strLabel2)
        rects3 = axisWidget.axis1.bar(x + 3*width/2, Depth3, 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 Depth')
        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()

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 7