吴恩达 深度学习第三周 浅层神经网络 logistic_regression python代码实现

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#%matplotlib inline

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
x = iris.data
y = iris.target
for i in range(len(y)):
    if y[i] == 2: y[i] =1
#print(y)
x_train,x_test, y_train, y_test = train_test_split(x,y,test_size = 0.3)
x_train = x_train.T
x_test  = x_test.T
y_train = y_train.reshape(1,-1)
y_tset  = y_test.reshape(1,-1)
print(y_test)
num_n1 = 4
num_n2 = 1
num_n0 = x_train.shape[0]
m_sample = x_train.shape[1]
learning_rate = 0.005

w1 = np.random.randn(num_n1, num_n0)*0.01
b1 = np.random.randn(num_n1).reshape(-1,1)*0.01
w2 = np.random.randn(num_n2,num_n1)*0.01
b2 = np.random.randn(num_n2).reshape(-1,1)*0.01

parameters =dict(w1=w1,w2=w2,b1=b1,b2=b2)
print(parameters['w2'],parameters['b2'])


def forward(x,parameters):
    #set parameters
    w1 = parameters['w1']    # shape n1 * n0
    w2 = parameters['w2']    # shape n2 * n1
    b1 = parameters['b1']    # shape n1 * 1
    b2 = parameters['b2']   # shape n2 * 1   actuall n2 = 1
    # cacl internal matrix
    Z1 = np.dot(w1,x)+b1     # shape n1 * m 
    A1 = 1.0/(1.0+np.exp(-Z1))  # shape n1 * m
    Z2 = np.dot(w2,A1) + b2     # shape n2 * m
    A2 = 1.0/(1.0 + np.exp(-Z2)) # shape n2 * m
    # matrix shape num 
    m  = x.shape[1]
    n0 = x.shape[0]
    n1 = w1.shape[0]
    n2 = w2.shape[0]
    #print('correct param m,n0,n1,n2\n',m,n0,n1,n2)
    assert(w2.shape[1] == n1)
    assert(Z1.shape[0] == n1 )
    assert( Z1.shape[1]==m)
    assert(A1.shape[0]== n1 )
    assert(A1.shape[1]==m)
    assert(Z2.shape[0]==n2 )
    assert(Z2.shape[1]==m)
    assert(A2.shape[0]==n2 )
    assert(A2.shape[1]==m)
    # return dict of internal matrix  
    temp = dict(Z1 = Z1,
                A1=A1,
                Z2=Z2,
                A2=A2)

    return temp
# backpropagation function 
def backward(X,Y,temp,parameter):
    '''
    INPUTS:
    X: input training feature datas  shape      n0 * m
    Y: input training labeled datas shape       1 * m
    temp: dict of transient matrix A1,Z1,A2,Z2
    parameter: dict structure , includeing : w1,b1,w2,b2    
    OUTPUS:
    dZ2: used calc deriative
    dw2: gradient   shape of 
    db2: gradient   shape of 
    dZ1: gradient   shape of 
    dw1: gradient   shape of 
    db1: gradient   shape of    
    '''
    # setting of internal matrix values
    A2 = temp['A2']     #shape  n2 * m
    A1 = temp['A1']     #shape  n1 * m
    Z1 = temp['Z1']     #shape  n1 * m
    Z2 = temp['Z2']     #shape  n2 * m
    w2 = parameters['w2']  # shape n2 * n1
    m_sample = X.shape[1]
    # calc gradient values in layer2
    dZ2 = A2 - Y                                   # shape  n2 * m
    dw2 = np.dot(dZ2, A1.T)                        # shape n2 * n1
    dw2 = dw2/np.float(m_sample)
    db2 = np.sum(dZ2,axis=1,keepdims=True)         # shape n2 * 1
    db2 = db2/np.float(m_sample)
    # calc gridient values in layer1
    GP  = np.multiply(A1,(1.0-A1))                 # shape n1 * m
    dZ1 = np.multiply(np.dot(w2.T,dZ2),GP)         # shape n1 * m
    dw1 = np.dot(dZ1,X.T)                          # shape n1 * n0
    dw1 = dw1/np.float(m_sample)
    db1 = np.sum(dZ1,axis=1,keepdims=True)         # shape n1 * 1
    db1 = db1/np.float(m_sample)    
    #----------------
    #-- check dims---
    #----------------
    n0 = X.shape[0]
    m  = X.shape[1]
    n1 = A1.shape[0]
    n2 = A2.shape[0]    
    assert(dZ2.shape == Z2.shape)
    assert(dw2.shape == w2.shape)
    assert(db2.shape[0] == n2)
    assert(dZ1.shape == Z1.shape)
    assert(dw1.shape[0]==n1)
    assert(dw1.shape[1]==n0)
    assert(db1.shape[0]==n1)
    assert(GP.shape == A1.shape)
    # set return values of gradients in two layers
    temp = dict(dZ2 = dZ2,
               dw2 = dw2,
               db2 = db2,
               dZ1 = dZ1,
               dw1 = dw1,
               db1 = db1)

    return temp
# loss function 
def get_loss(Y,catch):
    '''
    INPUTS:
    Y: input values  shape 1 * m
    catch : temp dict Z2,A2,Z1,A1 values
    A2: matrix used to calc loss  shape : (n2 * m   actually 1 * m)
    OUTPUS:
    return loss values
    loss: return values  shape: real number
    '''
    m = Y.shape[1]
    A2 = catch['A2']
    loss = np.dot(Y,(np.log(A2)).T) + np.dot((1.0-Y),np.log(1.0-A2).T)
    loss = -loss/np.float(m)    
    return loss 
# prediction function used to predict accuracy 
def predict(X,Y,parameters):
    '''
    function used to predict the results
    INPUTS:
    X: input matrix  shape:   n0 * m
    Y: input matrix  shape:   n2 * m   actually  1 * m
    parameters: w1,b1,w2,b2
    OUTPUS :
    accuracy : score in classification (real number)

    '''
    catch = forward(X,parameters)
    A2 = catch['A2']
    A2 = A2.reshape(-1,1)
    Y  = Y.reshape(-1,1)
    error_count = 0
    print(A2.shape,Y.shape)
    assert(len(Y) == len(A2))
    for i in range(len(A2)):
        if A2[i] >= 0.5:
            A2[i] = 1
        else:
            A2[i] = 0
    for i in range(len(Y)):
        if Y[i] != A2[i]:
            error_count +=1
    accuracy =1.0 - np.float(error_count)/np.float(len(Y))
    print('The Accuracy of network is:', accuracy)
    return accuracy
# function used to learning parameters
def parameter_learning(X,Y,X_test,Y_test,parameters,learning_rate):
    '''
    INPUTS:
    X: input values feats data  shape n0 * m
    Y: input values of labeled data  shape 1 * m
    parameters: including  w1,b1, w2,b2  using to describe models
    w1: first layer weighted values  shape: n1 * n0
    b1: first layer concate           shape: n1 * 1
    w2: second layer weighted values shape : n2 * n1
    b2: second layer concate          shape: n2 * 1
    learning_rate: learning_rate
    OUTPUTS:
    parameter:  final convergenced parameters
    dloss:      the relative errors of last two iterations  
    '''
    epoch_num = 10000
    w1 = parameters['w1']    # 此处的赋值，仅仅是把地址交给了变量w1  改变w1 其对应的 parameters中w1 也改变
    w2 = parameters['w2']
    b1 = parameters['b1']
    b2 = parameters['b2']
    plt.ion()
    train_accuracy= []
    test_accuracy = []
    steps = []
    residual = []
    plt.figure(1,figsize=(6,6))
    plt.figure(2,figsize=(6,6))
    for i in range(epoch_num):        
        catch = forward(X,parameters)
        gradient = backward(X,Y,catch, parameters)
        loss = get_loss(Y,catch)
        loss_temp = loss
        #gradient
        dw1 = gradient['dw1']
        db1 = gradient['db1']
        dw2 = gradient['dw2']
        db2 = gradient['db2']
        # update parameter values
        w1  += -learning_rate * dw1
        b1  += -learning_rate * db1
        w2  += -learning_rate * dw2
        b2  += -learning_rate * db2        
        catch = forward(X,parameters)
        loss = get_loss(Y,catch)       
        dloss = np.abs(loss-loss_temp)/(np.abs(loss)+0.0000001)
        # set of output and figures
        if(i%100 == 0):
            print('iteration num = ',i, 'dloss =', dloss,loss)
            steps.append(i)
            residual.append(dloss[0])
            plt.figure(1)
            train_accuracy.append(predict(X,Y,parameters))
            test_accuracy.append(predict(X_test,Y_test,parameters))
            line1,=plt.plot(steps,train_accuracy,'red',linewidth=1.5,label='Train Accuracy')
            line2,=plt.plot(steps,test_accuracy, 'green', linewidth=1.5,label='Test Accuracy')
            plt.ylim([0,1.3])
            plt.xlabel('Trainning steps')
            plt.ylabel('Trainning accuracy')
            plt.title('train/test VS steps')
            plt.legend([line1,line2],['Train Accuracy','Test Accuracy'], loc='upper right')
            plt.figure(2)
            line3, = plt.plot(steps,residual,'g-',linewidth=1.5,markersize=4,label='residual')
            plt.xlabel('Trainning steps')
            plt.ylabel('Trainning residual')
            plt.title('Trainning residual vs steps')
            plt.legend([line3],['Residual'],loc='upper right')          
            plt.pause(0.01)
        # define convergence criterion
        if dloss <=1.0e-6:
            print('iteration convergenced!!',dloss,i)
            return parameters,dloss
    return parameters,dloss

final_params,dloss = parameter_learning(x_train,y_train,x_test,y_test,parameters,learning_rate)
print('final loss:',dloss)
#print(final_params)