Comprensión, derivación, código y ejemplos de GD de descenso de gradiente (actualización)

# GD y ejemplo de ajuste lineal Ajuste
lineal de datos discretos, suponiendo que $y=\omega x$ es la curva que se va a ajustar [$f_\omega(x)=\sum\omega_i x_i$], el punto real es $ (x_0 ,y_0),(x_1, y_1), \cdots, (x_i, y_i)$, entonces la distancia entre el punto discreto $(\widehat{x_i}, \widehat{y_i})$ y la curva es $e_i$
$ $ e_i = (y_i-\widehat{y_i})^2$$
El error cuadrático medio es
$$
e = \frac{1}{n}\sum_{i=1}^n{(y_i-\widehat{y_i }) ^2}
=\frac{1}{n}\sum_{i=1}^n{(y_i-\omega\widehat{x_i})^2} = \frac
{1}{n}[{( y_1^ 2+\cdots+y_n^2)
-2\omega(x_1y_1+\cdots+x_ny_n)
+\omega^2(x_1^2+\cdots+x_n^2)}]
$$
$$
\begin{align* }
& \color{blue}{\sum_{i=1}^n{y_i^2} es c\quad\quad} &\color{ blue}{\sum_{i=1}^n{x_iy_i} es
b \quad \quad\quad\quad}\quad
&\color{blue}{\sum_{i=1}^n{x_i^2} es un}
\end{align*}
$$
Entonces la fórmula es la función de costo, que se puede simplificar como:
$$
e = a\omega^2 + b\omega + c
$$
Esta fórmula solo contiene un parámetro, a saber, $\omega$.
En la función de costo, necesita encontrar un punto, es decir, encontrar el parámetro apropiado $\omega_i$, para que la función de costo sea la más pequeña, es decir, usar el método de descenso de gradiente, al igual que escalar una montaña, encontrar el El lugar más empinado y bajar más rápido, y encontrar el punto más bajo, es el lugar con el menor costo. En otras palabras, es necesario buscar en la dirección con el gradiente más pequeño.

**¿Por qué se llama gradiente en lugar de derivada? **
En este ejemplo, solo hay un parámetro $\omega$, pero en general, hay muchos parámetros, es decir, $\omega_1, \omega_2,\cdots,\omega_j$, y los vectores parciales en cada dirección son Apílelos para obtener el vector que disminuye más rápido en una dirección determinada, es decir, el gradiente.

A continuación, calibre un punto inicial, deslícese hacia abajo desde el punto inicial y encuentre el punto más bajo. En este momento, la variable independiente es $\omega_i$ y la variable dependiente es la función de costo (pérdida) $e$. Encuentra un $\omega_i$ a lo largo de la dirección de la abscisa para que $e$ sea el más pequeño. El proceso es el siguiente:
$$ \omega_{n+1} = \omega_{n}-\alpha \frac{\partial e(\omega)}{\omega} $$ donde $ \alpha$ representa la tasa
de
aprendizaje , que es el paso Largo (bajar unos cuantos pasos cuesta abajo). Si la tasa de aprendizaje es un valor fijo y el valor es pequeño, entonces puede oscilar alrededor del punto más bajo; si el valor es demasiado grande, se perderá la oportunidad de bajar la montaña, por lo que las personas inteligentes piensan en multiplicar la pendiente por un valor (si solo hay un parámetro), cuanto mayor sea la pendiente, mayor será el tamaño del paso y cuanto menor sea la pendiente, más cuidadoso será bajar la montaña.

Funciones similares:
$$ e(\omega) = \frac{1}{n}\sum_{i=1}^n{(y_i-\widehat{y_i})^2} = \frac{1}{n
} \sum_{i=1}^n({y_i - f(x_i)})^2
$$
$$
\frac{\partial e(\omega)}{\omega} = \frac{1}{n}\ suma_{i=1}^n 2[y_i - f_\omega(x_i)]\cdot \frac{\partial f_\omega(x_i)}{\omega} $$desbloqueado$\frac{\partial f_ \
omega
( x_i)}{\omega}= \sum x_i$
则
$$
\frac{\partial e(\omega)}{\omega} = \frac{1}{n}\sum_{i=1}^n 2[ y_i - f_\omega(x_i)]\cdot \sum x_i
$$
则
$$
\omega_{n+1} = \omega_{n}-\alpha\frac{1}{n}\sum_{i= 1} ^n 2[y_i - f_\omega(x_i)]\cdot \sum x_i
$$

### Ejemplo de aplicación
Calcular el valor mínimo de $f(x,y) = x*sin(x)+xcos(y)+y^2-2y$

#### Álgebra

import math

def compute_partial_derivatives(x, y):
    df_dx = math.sin(x) + x * math.cos(x)
    df_dy = -x * math.sin(y) + 2 * y - 5
    return df_dx, df_dy

def gradient_descent():
    x = 0.0
    y = 0.0
    alpha = 0.01  # Learning rate
    iterations = 1000  # Maximum number of iterations

    for i in range(iterations):
        df_dx, df_dy = compute_partial_derivatives(x, y)

        x -= alpha * df_dx
        y -= alpha * df_dy

    f_value = x * math.sin(x) + x * math.cos(y) + y**2 - 5 * y

    return f_value, x, y

result, x_min, y_min = gradient_descent()

print("Smallest value of f(x, y):", result)
print("x value at minimum:", x_min)
print("y value at minimum:", y_min)

#### Notación

import sympy as sp

x, y = sp.symbols('x y')

def compute_partial_derivatives(f):
    df_dx = sp.diff(f, x)
    df_dy = sp.diff(f, y)
    return df_dx, df_dy

def gradient_descent():
    x_val = 0.0
    y_val = 0.0
    alpha = 0.01  # Learning rate
    iterations = 1000  # Maximum number of iterations

    for i in range(iterations):
        df_dx, df_dy = compute_partial_derivatives(f)
        # 用x_val和y_val替代原先的x和y，然后计算新的df_dx_val和df_dy_val
        df_dx_val = df_dx.subs([(x, x_val), (y, y_val)])
        df_dy_val = df_dy.subs([(x, x_val), (y, y_val)])

        x_val -= alpha * df_dx_val
        y_val -= alpha * df_dy_val
        
    return x_val, y_val

f = x * sp.sin(x) + x * sp.cos(y) + y**2 - 5 * y

x_min, y_min = gradient_descent()
result = x_min * sp.sin(x_min) + x_min * sp.cos(y_min) + y_min**2 - 5 * y_min
print("Smallest value of f(x, y):", result)
print("x value at minimum:", x_min)
print("y value at minimum:", y_min)

#### Dibujo

import numpy as np
import matplotlib.pyplot as plt

def f(x, y):
    return x * np.sin(x) + x * np.cos(y) + y**2 - 5*y

# Create a grid of x and y values
x = np.linspace(-10, 10, 100)
y = np.linspace(-10, 10, 100)
X, Y = np.meshgrid(x, y)

# Evaluate the function f(x, y) for each (x, y) pair
Z = f(X, Y)

# Plot the surface
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis')

# Set labels and title
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('f(x, y)')
ax.set_title('f(x, y) = x*sin(x) + x*cos(y) + y^2 - 5y')

# Show the plot
plt.show()