J'essaie de mettre en œuvre une solution de régression de Ridge en Python en utilisant la descente de gradient stochastique comme solveur. Mon code SGD est comme suit:Régression de crête utilisant la descente de gradient stochastique en Python
def fit(self, X, Y):
# Convert to data frame in case X is numpy matrix
X = pd.DataFrame(X)
# Define a function to calculate the error given a weight vector beta and a training example xi, yi
# Prepend a column of 1s to the data for the intercept
X.insert(0, 'intercept', np.array([1.0]*X.shape[0]))
# Find dimensions of train
m, d = X.shape
# Initialize weights to random
beta = self.initializeRandomWeights(d)
beta_prev = None
epochs = 0
prev_error = None
while (beta_prev is None or epochs < self.nb_epochs):
print("## Epoch: " + str(epochs))
indices = range(0, m)
shuffle(indices)
for i in indices: # Pick a training example from a randomly shuffled set
beta_prev = beta
xi = X.iloc[i]
errori = sum(beta*xi) - Y[i] # Error[i] = sum(beta*x) - y = error of ith training example
gradient_vector = xi*errori + self.l*beta_prev
beta = beta_prev - self.alpha*gradient_vector
epochs += 1
Les données que je teste ce n'est pas normalisée et ma mise en œuvre se termine toujours avec tous les poids étant infini, même si j'initialiser le vecteur de poids à des valeurs faibles. Ce n'est que lorsque je mets le taux d'apprentissage alpha à une très petite valeur ~ 1e-8, l'algorithme se termine avec des valeurs valides du vecteur de poids. D'après ce que je comprends, normaliser/mettre à l'échelle les entités en entrée ne fait que réduire le temps de convergence. Mais l'algorithme ne devrait pas manquer de converger dans son ensemble si les fonctionnalités ne sont pas normalisées. Est-ce que ma compréhension est correcte?