neuronales - gradiente descendente matlab

Vectorización de un algoritmo de descenso de gradiente.

Question

Estoy codificando pendiente de gradiente en matlab. Para dos características, obtengo para el paso de actualización:

temp0 = theta(1,1) - (alpha/m)*sum((X*theta-y).*X(:,1));
temp1 = theta(2,1) - (alpha/m)*sum((X*theta-y).*X(:,2));
theta(1,1) = temp0;
theta(2,1) = temp1;

Sin embargo, quiero vectorizar este código y poder aplicarlo a cualquier número de funciones. Para la parte de vectorización, se me indicó que lo que estoy tratando de hacer es una multiplicación de matrices.

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

Esto se ve bien, pero cuando lo intenté, me di cuenta de que no funciona para el descenso de gradiente porque los parámetros no se actualizan simultáneamente.

Entonces, ¿cómo puedo vectorizar este código y asegurarme de que los parámetros se actualicen al mismo tiempo?

Answer 1

Aquí está la forma vectorizada de pendiente de gradiente que funciona para mí en octava.
recuerde que X es una matriz con unos en la primera columna (ya que theta_0 *1 es thetha_0 ). Para cada columna en X tiene una característica (n) en X. Cada fila es un conjunto de entrenamiento (m). entonces X am X (n + 1) matriz. El vector de la columna y podría ser el precio de la vivienda. Es bueno tener una función de costo para verificar si encuentra un mínimo.
elija un valor para alfa tal vez a = 0.001 e intente cambiarlo cada vez que ejecute el código. Los num_iters son las veces que desea que se ejecute.

function theta = gradientDescent(X, y, theta, alpha, num_iters)
m = length(y); % number of training examples
for iter = 1:num_iters
theta = theta - (alpha/m) * (X'') * ((X*theta)-y)
end
end

vea la explicación completa aquí: https://www.coursera.org/learn/machine-learning/resources/QQx8l

Answer 2

Para actualizarlos simultáneamente, debe mantener el valor de theta (1..n) en un vector temporal y, después de la operación, simplemente actualizar los valores en el vector theta original.

Este es el código que uso para este propósito:

Actualización de temperatura

tempChange = ceros (longitud (theta), 1);

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

Actual actualizacion

theta = tempChage;

Answer 3

Para la versión vectorizada, intente lo siguiente (dos pasos para realizar actualizaciones simultáneas explícitamente):

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

Answer 4

Soy muy nuevo en este tema, pero mi opinión es: si calcula X*theta , mientras realiza una operación vectorizada para ajustar theta, no necesita estar en temp. en otras palabras: si calcula X*theta al actualizar theta vector, theta (1) se actualiza antes que theta (2) y, por lo tanto, cambia X*theta . pero si calculamos X*theta como y_pred y luego hacemos vectorizar op en theta, estará bien.

así que mi sugerencia es (sin usar temp):

y_pred = X*theta %theta is [1;1] and X is mX2 matrix
theta = theta - (alpha/m) * (X'' * (y_pred-y));

Por favor, corríjame si estoy equivocado.

Answer 5

Su vectorización es correcta. También probé ambos códigos, y me dieron la misma theta. Solo recuerda que no uses tu actualización theta en tu segunda implementación.

Esto también funciona, pero menos simplificado que su segunda implementación:

Error = X * theta - y;
for i = 1:2
S(i) = sum(Error.*X(:,i));
end
theta = theta - alpha * (1/m) * S''

Answer 6

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