Cómo determinar la tasa de aprendizaje y la varianza en un algoritmo de pendiente de gradiente

Comencé a aprender la máquina de aprender la semana pasada. cuando quiero hacer un guión de pendiente de gradiente para estimar los parámetros del modelo, me encontré con un problema: cómo elegir una tasa de aprendizaje y una varianza adecuadas. Encontré que , pares diferentes (tasa de aprendizaje, varianza) pueden llevar a resultados diferentes, algunos veces ni siquiera se puede convergir. Además, si se cambia a otro conjunto de datos de entrenamiento, un par de tasa de aprendizaje bien elegido, varianza y probablemente no funcionará. Por ejemplo (secuencia de comandos a continuación), cuando establezco la velocidad de aprendizaje en 0.001 y la varianza en 0.00001, para ‘data1’, puedo obtener el theta0_guess y theta1_guess adecuados. Pero para ‘data2’, no pueden hacer que el algoritmo converja, incluso cuando probé docenas de rate tasa de aprendizaje, varianza,) pares que aún no pueden alcanzar la convergencia.

Entonces, si alguien me puede decir que hay algunos criterios o métodos para determinar el par de rate tasa de aprendizaje, varianza).

import sys data1 = [(0.000000,95.364693) , (1.000000,97.217205) , (2.000000,75.195834), (3.000000,60.105519) , (4.000000,49.342380), (5.000000,37.400286), (6.000000,51.057128), (7.000000,25.500619), (8.000000,5.259608), (9.000000,0.639151), (10.000000,-9.409936), (11.000000, -4.383926), (12.000000,-22.858197), (13.000000,-37.758333), (14.000000,-45.606221)] data2 = [(2104.,400.), (1600.,330.), (2400.,369.), (1416.,232.), (3000.,540.)] def create_hypothesis(theta1, theta0): return lambda x: theta1*x + theta0 def linear_regression(data, learning_rate=0.001, variance=0.00001): theta0_guess = 1. theta1_guess = 1. theta0_last = 100. theta1_last = 100. m = len(data) while (abs(theta1_guess-theta1_last) > variance or abs(theta0_guess - theta0_last) > variance): theta1_last = theta1_guess theta0_last = theta0_guess hypothesis = create_hypothesis(theta1_guess, theta0_guess) theta0_guess = theta0_guess - learning_rate * (1./m) * sum([hypothesis(point[0]) - point[1] for point in data]) theta1_guess = theta1_guess - learning_rate * (1./m) * sum([ (hypothesis(point[0]) - point[1]) * point[0] for point in data]) return ( theta0_guess,theta1_guess ) points = [(float(x),float(y)) for (x,y) in data1] res = linear_regression(points) print res 

El trazado es la mejor manera de ver cómo se está desempeñando su algoritmo. Para ver si ha alcanzado la convergencia, puede trazar la evolución de la función de costo después de cada iteración, después de una determinada iteración verá que no mejora mucho, puede asumir la convergencia, consulte el siguiente código:

 cost_f = [] while (abs(theta1_guess-theta1_last) > variance or abs(theta0_guess - theta0_last) > variance): theta1_last = theta1_guess theta0_last = theta0_guess hypothesis = create_hypothesis(theta1_guess, theta0_guess) cost_f.append((1./(2*m))*sum([ pow(hypothesis(point[0]) - point[1], 2) for point in data])) theta0_guess = theta0_guess - learning_rate * (1./m) * sum([hypothesis(point[0]) - point[1] for point in data]) theta1_guess = theta1_guess - learning_rate * (1./m) * sum([ (hypothesis(point[0]) - point[1]) * point[0] for point in data]) import pylab pylab.plot(range(len(cost_f)), cost_f) pylab.show() 

Lo que trazará el siguiente gráfico (ejecución con learning_rate = 0.01, varianza = 0.00001)

Como puedes ver, después de mil iteraciones no obtienes mucha mejora. Normalmente declaro convergencia si la función de costo disminuye menos de 0.001 en una iteración, pero esto solo se basa en mi propia experiencia.

Para elegir la tasa de aprendizaje, lo mejor que puede hacer es trazar la función de costo y ver cómo se está desempeñando, y siempre recuerde estas dos cosas:

  • Si la velocidad de aprendizaje es demasiado pequeña, obtendrá una convergencia lenta.
  • Si la tasa de aprendizaje es demasiado grande, su función de costo puede no disminuir en cada iteración y, por lo tanto, no convergerá

Si ejecuta su código seleccionando learning_rate> 0.029 y varianza = 0.001 estará en el segundo caso, el descenso del gradiente no converge, mientras que si elige valores learning_rate <0.0001, varianza = 0.001 verá que su algoritmo toma una gran iteración para converger.

Ejemplo de no convergencia con learning_rate = 0.03

Ejemplo de convergencia lenta con learning_rate = 0.0001 introduzca la descripción de la imagen aquí

Hay un montón de maneras de garantizar la convergencia de un algoritmo de pendiente de gradiente. Hay una búsqueda de líneas, un tamaño de paso fijo relacionado con la constante de Lipschitz del gradiente (es decir, en el caso de una función. En el caso de una tabla como la suya, puede hacer la diferencia entre valores consecutivos), un tamaño de paso decreciente para Cada iteración y algunas otras. Algunos de ellos se pueden encontrar aquí .