En la regresión lineal, el objetivo del modelo es obtener la línea de regresión que mejor se ajuste para predecir el valor de y en función del valor de entrada dado (x). Mientras entrena el modelo, el modelo calcula la función de costo que mide el error cuadrático medio entre el valor predicho (pred) y el valor real (y). El modelo apunta a minimizar la función de costo.
Para minimizar la función de costo, el modelo debe tener el mejor valor de θ 1 y θ 2 . Inicialmente, el modelo selecciona aleatoriamente los valores de θ 1 y θ 2 y luego actualiza iterativamente estos valores para minimizar la función de costo hasta que alcance el mínimo. Para cuando el modelo alcance la función de costo mínimo, tendrá los mejores θ 1 y θ 2valores. Usando estos valores finalmente actualizados de θ 1 y θ 2 en la ecuación de hipótesis de la ecuación lineal, el modelo predice el valor de x de la mejor manera posible.
Por lo tanto, surge la pregunta: ¿Cómo se actualizan los valores de θ 1 y θ 2 ?
Función de costo de regresión lineal:
Algoritmo de descenso de gradiente para regresión lineal
-> θj : Weights of the hypothesis. -> hθ(xi) : predicted y value for ith input. -> j : Feature index number (can be 0, 1, 2, ......, n). -> α : Learning Rate of Gradient Descent.
Graficamos la función de costo como una función de las estimaciones de parámetros, es decir, el rango de parámetros de nuestra función de hipótesis y el costo resultante de seleccionar un conjunto particular de parámetros. Nos movemos hacia abajo, hacia los hoyos en el gráfico, para encontrar el valor mínimo. La forma de hacerlo es derivar la función de costo como se explica en la figura anterior. Gradient Descent reduce la función de costo en la dirección del descenso más pronunciado. El tamaño de cada paso está determinado por el parámetro α conocido como Tasa de aprendizaje .
En el algoritmo de descenso de gradiente, se pueden inferir dos puntos:
- Si la pendiente es +ve : θ j = θ j – (+valor ve). Por lo tanto, el valor de θ j disminuye.
- Si la pendiente es -ve : θ j = θ j – (valor -ve). Por lo tanto, el valor de θ j aumenta.
La elección de la tasa de aprendizaje correcta es muy importante ya que asegura que el descenso de gradiente converja en un tiempo razonable. :
- Si elegimos que α sea muy grande , Gradient Descent puede sobrepasar el mínimo. Puede no converger o incluso divergir.
- Si elegimos que α sea muy pequeño, Gradient Descent tomará pequeños pasos para alcanzar los mínimos locales y tomará más tiempo para alcanzar los mínimos.
la
Python3
# Implementation of gradient descent in linear regression
import numpy as np
import matplotlib.pyplot as plt
class Linear_Regression:
def __init__(self, X, Y):
self.X = X
self.Y = Y
self.b = [0, 0]
def update_coeffs(self, learning_rate):
Y_pred = self.predict()
Y = self.Y
m = len(Y)
self.b[0] = self.b[0] - (learning_rate * ((1/m) *
np.sum(Y_pred - Y)))
self.b[1] = self.b[1] - (learning_rate * ((1/m) *
np.sum((Y_pred - Y) * self.X)))
def predict(self, X=[]):
Y_pred = np.array([])
if not X: X = self.X
b = self.b
for x in X:
Y_pred = np.append(Y_pred, b[0] + (b[1] * x))
return Y_pred
def get_current_accuracy(self, Y_pred):
p, e = Y_pred, self.Y
n = len(Y_pred)
return 1-sum(
[
abs(p[i]-e[i])/e[i]
for i in range(n)
if e[i] != 0]
)/n
#def predict(self, b, yi):
def compute_cost(self, Y_pred):
m = len(self.Y)
J = (1 / 2*m) * (np.sum(Y_pred - self.Y)**2)
return J
def plot_best_fit(self, Y_pred, fig):
f = plt.figure(fig)
plt.scatter(self.X, self.Y, color='b')
plt.plot(self.X, Y_pred, color='g')
f.show()
def main():
X = np.array([i for i in range(11)])
Y = np.array([2*i for i in range(11)])
regressor = Linear_Regression(X, Y)
iterations = 0
steps = 100
learning_rate = 0.01
costs = []
#original best-fit line
Y_pred = regressor.predict()
regressor.plot_best_fit(Y_pred, 'Initial Best Fit Line')
while 1:
Y_pred = regressor.predict()
cost = regressor.compute_cost(Y_pred)
costs.append(cost)
regressor.update_coeffs(learning_rate)
iterations += 1
if iterations % steps == 0:
print(iterations, "epochs elapsed")
print("Current accuracy is :",
regressor.get_current_accuracy(Y_pred))
stop = input("Do you want to stop (y/*)??")
if stop == "y":
break
#final best-fit line
regressor.plot_best_fit(Y_pred, 'Final Best Fit Line')
#plot to verify cost function decreases
h = plt.figure('Verification')
plt.plot(range(iterations), costs, color='b')
h.show()
# if user wants to predict using the regressor:
regressor.predict([i for i in range(10)])
if __name__ == '__main__':
main()
Producción:
Nota: Regularización
Publicación traducida automáticamente
Artículo escrito por Mohit Gupta_OMG 🙂 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA