Переполнение при расчете частных производных градиента в Python - PullRequest
Новая
       23

Переполнение при расчете частных производных градиента в Python

0 голосов
/ 10 июля 2020

Я сделал функцию def в python, где я мог делать простые частные производные градиента для обновления переменных в нейронной сети, которая является очень простой c аппроксимационной функцией без функций активации. Это для одного входа x1, который пытается оценить выход y.

У меня также есть функция определения стандартизации, и когда я запускаю свой код, но сначала стандартизирую набор входных данных, у меня нет проблем. Когда я запускаю набор необработанных данных через ту же функцию частичных производных градиента, тогда, когда я выполняю обновление для переменных m и b, точность мгновенно становится огромной, и у меня возникает проблема с переполнением.

Кто-нибудь знает, как я могу решить это? Я смог понять, что это происходит из-за обновления переменных m и b, которые возвращаются в y. Но я не уверен, как это решить? Из-за некоторого быстрого поиска в Google я не нашел никаких решений, кроме людей, которые говорят, что переполнение - это проблема, когда точность вашего числа превышает предел типа данных, который вы используете. Как остановить переполнение? 

import os
import numpy as np
import random
import csv
import urllib.request
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D


########################## Setting the working directory #####################
abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
os.chdir(dname)

########## Downloading the data set to the current working directory #########
url = 'https://raw.githubusercontent.com/tofighi/MachineLearning/master/datasets/student_marks.csv'
urllib.request.urlretrieve(url,filename = 'data.csv')
data = np.genfromtxt(fname = 'data.csv', dtype = float, delimiter = ',', skip_header=0)
data = np.delete(data,(0),axis=0)


def standardization(data):
    x = np.zeros((len(data),2))
    mean_data1 = np.mean(data[:,0])
    std_data1 = np.std(data[:,0])
    
    mean_data2 = np.mean(data[:,1])
    std_data2 = np.std(data[:,1])
    
    for i in range(0,len(x)):
        x[i,0]= ((data[i,0] - mean_data1)/std_data1);
        x[i,1]= ((data[i,1] - mean_data2)/std_data2);
    return x

def gradient_Partial_Derivatives(nEpoch,N,b,m,x):
    #m_tracker = np.zeros(nEpoch*N)
    #b_tracker = np.zeros(nEpoch*N)
    error = np.zeros(nEpoch*N)

    counter = 0
    error_sum = 0
    sum_counter = 1
    #Training m and b
    for epoch in range(0,nEpoch):
        a=range(0,len(x))
        sp=random.sample(a,len(x))
        
        for j in range(0,N):
            #Calculate new final grade based on midterm. Training estimate for y.
            y = b + m*x[sp[j],0];

            #Find the error between estimate final y and target final x[j,1]
            #This is not the error function but just e = y_actual - y_estimate
            e = x[sp[j],1] - y;
            
            #Update m and b using partial derivatives
            m = m + alpha*(2/(sum_counter))*e*x[sp[j],0]
            b = b + alpha*(2/(sum_counter))*e
            
            er = (((x[sp[j],1])-(y))**2)
            error_sum = error_sum + er
            error[counter] = error_sum/(sum_counter)
            #m_tracker[counter] = m;
            #b_tracker[counter] = b;
            counter = counter + 1;
            sum_counter = sum_counter + 1
    
    return m, b, error

########################### Initializing Variables ###########################
m = -0.5;
b = 0;
alpha = 0.1;

##############################################################################
##############################################################################
############################## Standardization ###############################

#Standardizing the input
x_standard = standardization(data)

#Calcualting partial derivative and updating m and b
m_final, b_final, er = gradient_Partial_Derivatives(1,100, b, m, x_standard)

#Calcualting partial derivative and updating m and b for 2000 iterations
m_final1, b_final1, er1 = gradient_Partial_Derivatives(20,100, b, m, x_standard)

##############################################################################
##############################################################################
############################ No Standardization ##############################


#Calcualting partial derivative and updating m and b
m_final2, b_final2, er2 = gradient_Partial_Derivatives(1,100, b, m, data)

#Calcualting partial derivative and updating m and b for 2000 iterations
m_final3, b_final3, er3 = gradient_Partial_Derivatives(20,100, b, m, data)

1 Ответ

0 голосов
/ 10 июля 2020

Итак, для тех, кто читает, я добавил sum_counter непосредственно перед публикацией здесь, чтобы посмотреть, решит ли это проблему переполнения в частных производных градиента def. Я думал, что это не сработало, но после повторного запуска кода я не получаю ошибки переполнения, и это было единственное изменение, которое я сделал. Раньше я делил m и b на переменную N, которая всегда была установлена ​​на 100 и не накапливалась, как обновления. Кажется, это все устранило.

...