Erreur d'exécution de descente de dégradé

Question

J'ai fait une implémentation simple de la descente en dégradé pour python et ça marche bien pour la plupart des paramètres mais pour certains paramètres de taux d'apprentissage et nombre d'itérations cela me donne une erreur d'exécution.

RuntimeWarning: débordement rencontré dans double_scalars

RuntimeWarning: valeur non valide rencontré dans double_scalars

Maintenant, je suppose, car il arrive à un point où les valeurs de b et m deviennent trop grand pour stocker en mémoire car il y avait une erreur de débordement, cette hypothèse est-elle correcte?

Et comment puis-je empêcher le programme de se bloquer car la gestion des exceptions dans le programme principal ne semble pas fonctionner et pouvez-vous penser à un moyen sans gestion des exceptions pour éviter l'erreur logiquement?

def compute_error(points,b,m): 
    error = 0 
    for i in range(len(points)): 
     y = ponts[i][1] 
     x = points[i][0] 
     error += (y - (m*x + b))**2 
    return error/len(points) 

def gradient_runner(points,LR,num_iter,startB=0,startM=0): 
    b = startB 
    m = startM 
    for i in range(num_iter): 
     b,m = step_gradient(points,b,m,LR) 
    return [b,m] 

def step_gradient(points,b,m,LR): 
    b_gradient = 0 
    m_gradient = 0 
    N = float(len(points)) 
    for i in range(len(points)): 
     x = points[i][0] 
     y = points[i][1] 
     b_gradient+= (-2/N)*(y - ((m*x)+b)) 
     m_gradient+= (-2/N)*x*(y - ((m*x)+b)) 
## print "Value for b_gradient",b_gradient 
## print "Value for b is ",b 
## print "Value for learning rate is ",LR 
    new_b = b - (LR * b_gradient) 
    new_m = m - (LR * m_gradient) 
    return [new_b,new_m]  

import numpy as np 
a = np.array([[1,1],[4,2],[6,3],[8,4],[11,5],[12,6],[13,7],[16,8]]) 

b,m=gradient_runner(a,0.0001,1000) # These parameters work 
# b,m=gradient_runner(a,0.1,10000) #Program Crashes 
yguesses = [m * i + b for i in a[:,0]] 


import matplotlib.pyplot as plt 

guezz= yguesses 

plt.scatter(a[:,0], a[:,1] ,color="green") 
plt.plot(a[:,0],guezz,color="red") 

plt.show() 

Answer 1

Le problème est le « taux d'apprentissage » LR (test ce en changeant seulement LR - vous constaterez que si vous allez assez bas, l'algorithme converge). Avec une valeur trop élevée de LR, vous prenez un pas trop important à chaque fois (imaginez que vous sautez par-dessus la valeur correcte à chaque étape). Il existe des moyens de calculer la taille de pas maximale. Google autour d'un peu (par exemple "taille de l'étape de descente de gradient"). Cependant, comme vous le constatez, si vous obtenez un débordement, le résultat sera probablement erroné. En Python vous pouvez catch warnings, que vous pourriez utiliser pour dire à l'utilisateur que le résultat est faux.