Блог

Я написал некоторый код на python, используя numpy, для обучения простого NN с использованием мини-пакетного метода и RMSProp, но точность обучения довольно высока, и также было предупреждение: :43: Предупреждение о времени выполнения: переполнение, встречающееся в exp ZZ = np.exp(z)/np.sum(np.exp(z)) :43: Предупреждение о времени выполнения: недопустимое значение, встречающееся в true_divide ZZ = np.exp(z)/np.sum(np.exp(z))

может ли кто-нибудь помочь мне с этим? Спасибо.

Вот мой код:

 import numpy as np   
import h5py
import time
import copy
from random import randint
import random

#load MNIST data
MNIST_data = h5py.File('MNISTdata.hdf5', 'r')
x_train = np.float32(MNIST_data['x_train'][:] )
y_train = np.int32(np.array(MNIST_data['y_train'][:,0]))
x_test = np.float32( MNIST_data['x_test'][:] )
y_test = np.int32( np.array( MNIST_data['y_test'][:,0]  ) )

MNIST_data.close()

#Implementation of stochastic gradient descent algorithm

#number of inputs
num_inputs = 28*28

#number of outputs
num_outputs = 10

model = {}

model['W1'] = np.random.randn(num_outputs,num_inputs) / np.sqrt(num_inputs)  

model_grads = copy.deepcopy(model)


def softmax_function(z):
    ZZ = np.exp(z)/np.sum(np.exp(z))
    return ZZ

def forward(x,y, model):
    Z =  np.dot(model['W1'], x) #x的shape为（784，）
    p = softmax_function(Z)
    return p

def backward(x,y,p, model, model_grads):  
    dZ = -1.0*p    
    dZ[y] = dZ[y]   1.0
    
    for i in range(num_outputs):
        model_grads['W1'][i,:] = dZ[i]*x   
    #model_grads['W1']=np.array(np.matrix(dZ).T*np.matrix(x))  
   
     
    return model_grads
    

LR = .01
num_epochs = 60
batch=100

for epochs in range(num_epochs):
    #Learning rate schedule
    if (epochs > 5):
        ng = 0.001
    if (epochs > 10):
        ng = 0.0001
    if (epochs > 15):
        ng = 0.00001
        
    r=0.0
    s=0.0
    ro=0.9
    delta=0.0001
            
    total_correct = 0
    
    I_permutation = np.random.permutation(len(y_train))
    x_train =  x_train[I_permutation,:]
    y_train =  y_train[I_permutation] 
    
    for n in range(1,len(x_train) 1,batch):
        
        x_train_mini = x_train[n-1:n -1  batch]
        y_train_mini = y_train[n-1:n -1  batch]
        
        W1=0.0
        
        for i in range(batch):
            x=x_train_mini[i]
            y=y_train_mini[i]
            p = forward(x, y, model)
            prediction = np.argmax(p)
            if (prediction == y):
                total_correct  = 1
        
            model_grads = backward(x,y,p, model, model_grads)
            W1 =model_grads['W1']/batch
        
        
        r=ro*r (1-ro)*W1*W1
        model['W1'] = model['W1']-ng/((delta r)**(1/2))*W1
           
    print(total_correct/np.float(len(x_train) ) )


#test data
total_correct = 0
for n in range( len(x_test)):
    y = y_test[n]
    x = x_test[n][:]
    p = forward(x, y, model)
    prediction = np.argmax(p)
    if (prediction == y):
        total_correct  = 1
        
print(total_correct/np.float(len(x_test) ) )