el descenso de gradiente parece fallar

Vectoricé la cosa theta... may podría ayudar a alguien

theta = theta - (alpha/m *  (X * theta-y)' * X)';

Si se pregunta cómo el bucle for de aspecto aparentemente complejo puede ser vectorizado y reducido a una sola expresión de línea, siga leyendo. La forma vectorizada es:

theta = theta - (alpha/m) * (X' * (X * theta - y))

A continuación se da una explicación detallada de cómo llegamos a esta expresión vectorizada utilizando el algoritmo de descenso de gradiente:

Este es el algoritmo de descenso de gradiente para afinar el valor de θ:

Supongamos que los siguientes valores de X, y y θ se dan:

• m = número de ejemplos de entrenamiento
• n = número de características + 1

Aquí

• m = 5 (ejemplos de entrenamiento)
• n = 4 (características+1)
• X = m x n matriz
• y = m x 1 matriz vectorial
• θ = n x 1 matriz vectorial
• xⁱ es el i^th formación ejemplo
• x _j es la característica j^th en un entrenamiento dado ejemplo

Además,

• h(x) = ([X] * [θ]) (m x 1 matriz de valores predichos para nuestro conjunto de entrenamiento)
• h(x)-y = ([X] * [θ] - [y]) (m x 1 matriz de errores en nuestras predicciones)

todo el objetivo del aprendizaje automático es minimizar los errores en las predicciones. Basado en el corolario anterior, nuestra matriz de errores es m x 1 matriz vectorial de la siguiente manera:

Para calcular el nuevo valor de θ_j, tenemos que obtener una suma de todos errores (filas m) multiplicados por j^th valor de característica del conjunto de entrenamiento X. Es decir, tomar todos los valores en E, multiplicarlos individualmente con j^th característica del correspondiente ejemplo de entrenamiento, y sumarlos todos juntos. Esto nos ayudará a obtener el nuevo (y esperemos que mejor) valor de θ _j . Repita este proceso para todos j o el número de entidades. En forma de matriz, esto se puede escribir como:

Esto puede ser simplificada como:

• [E]' x [X] nos dará una matriz vectorial fila, ya que E' es 1 x m matriz y X es m x n matriz. Pero estamos interesados en obtener una matriz de columna, por lo tanto transponemos la matriz resultante.

Más sucintamente, se puede escribir como:

Desde (A * B)' = (B' * A'), y A'' = A, también podemos escribir lo anterior como

Esta es la expresión original con la que empezamos:

theta = theta - (alpha/m) * (X' * (X * theta - y))

Si está de acuerdo con el uso de una función de costo de mínimos cuadrados, entonces podría intentar usar la ecuación normal en lugar del descenso de gradiente. Es mucho más simple only solo una línea comput y computacionalmente más rápido.

Aquí está la ecuación normal: http://mathworld.wolfram.com/NormalEquation.html

Y en forma de octava:

theta = (pinv(X' * X )) * X' * y

Aquí hay un tutorial que explica cómo usar la ecuación normal: http://www.lauradhamilton.com/tutorial-linear-regression-with-octave

Aunque no es escalable como una versión vectorizada, un cálculo basado en bucles de un descenso de gradiente debería generar los mismos resultados. En el ejemplo anterior, el caso más probable de que el descenso del gradiente no calcule el theta correcto es el valor de alfa.

Con un conjunto verificado de funciones de descenso de costos y gradiente y un conjunto de datos similar al descrito en la pregunta, theta termina con valores NaN justo después de unas cuantas iteraciones si alpha = 0.01. Sin embargo, cuando se establece como alpha = 0.000001, el descenso del gradiente funciona como se esperaba, incluso después de 100 iteraciones.

Usando solo vectores aquí está la implementación compacta de LR con Descenso de Gradiente en Mathematica:

Theta = {0, 0}
alpha = 0.0001;
iteration = 1500;
Jhist = Table[0, {i, iteration}];
Table[  
  Theta = Theta - 
  alpha * Dot[Transpose[X], (Dot[X, Theta] - Y)]/m; 
  Jhist[[k]] = 
  Total[ (Dot[X, Theta] - Y[[All]])^2]/(2*m); Theta, {k, iteration}]

Nota: Por supuesto uno asume que X es una matriz n * 2, con X [[, 1]] conteniendo solamente 1s'

Esto debería funcionar:-

theta(1,1) = theta(1,1) - (alpha*(1/m))*((X*theta - y)'* X(:,1) ); 

theta(2,1) = theta(2,1) - (alpha*(1/m))*((X*theta - y)'* X(:,2) ); 

Es más limpio de esta manera, y vectorizado también

predictions = X * theta;
errorsVector = predictions - y;
theta = theta - (alpha/m) * (X' * errorsVector);