Ejemplo 1: Cálculo del error cuadrático medio con diferentes valores de w Modelo: ( y = x \cdot w )

import numpy as np
import matplotlib.pyplot as plt

# Datos de entrada
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

def predecir(x):
    return x * w

def calcular_error(y_pred, y):
    return (y_pred - y) ** 2

w_list = []
mse_list = []

for w in np.arange(0.0, 4.1, 0.1):
    print(f"-----------w={w}-------------------------")
    loss_sum = 0
    for x_val, y_val in zip(x_data, y_data):
        y_pred = predecir(x_val)
        loss_val = calcular_error(y_pred, y_val)
        loss_sum += loss_val
        print(f'x_val={x_val}, y_val={y_val}, y_pred={y_pred}, loss_val={loss_val}')
    mse = loss_sum / len(x_data)
    print(f"-----------MSE={mse}----------")
    w_list.append(w)
    mse_list.append(mse)

plt.plot(w_list, mse_list)
plt.ylabel("Pérdida")
plt.xlabel('w')
plt.show()

Ejemplo 2: Simulación de regresión lineal con descenso del gradiente Modelo: ( y = x \cdot w )

import numpy as np
import matplotlib.pyplot as plt

# Datos de entrada
x_data = [1.0, 2.0, 3.0, 4.0, 5.0]
y_data = [2.0, 4.0, 6.0, 8.0, 10.0]

w = 1.0

def predecir(x):
    return x * w

def calcular_mse(x_data, y_data):
    loss_sum = 0
    for x, y in zip(x_data, y_data):
        y_pred = predecir(x)
        loss_sum += (y_pred - y) ** 2
    return loss_sum / len(x_data)

def calcular_gradiente(x_data, y_data):
    gradient = 0
    for x, y in zip(x_data, y_data):
        gradient += (x * w - y) * x
    return gradient / len(x_data)

mse_list = []
w_list = []

print("Antes del entrenamiento:", 6, predecir(6))
for epoch in range(100):
    loss_val = calcular_mse(x_data, y_data)
    mse_list.append(loss_val)
    grad_val = calcular_gradiente(x_data, y_data)
    w -= 0.01 * grad_val
    w_list.append(w)
    print(f"Epoch={epoch}, w={w}, loss={loss_val}")
print("Predicción (después del entrenamiento)", 6, predecir(6))

plt.plot(w_list, mse_list)
plt.ylabel("Pérdida")
plt.xlabel('w')
plt.show()

Ejemplo 3: Simulaicón de regresión lineal con descenso del gradietne (y = x * w + b) Datos de entrada: X, W, Y, B

import matplotlib.pyplot as plt
import numpy as np

def calcular_costo(X, y, theta):
    m = y.shape[0]
    inner = np.power((X @ theta - y.T), 2)
    return np.sum(inner) / (2 * m)

def descenso_del_gradiente(X, y, theta, alpha, num_iters):
    m = y.shape[0]
    cost = np.zeros(num_iters)
    for i in range(num_iters):
        h = X @ theta
        loss = h - y.T
        gradient = (X.T @ loss) / m
        theta -= alpha * gradient
    return theta

def regresion_lineal(x, y):
    theta = np.zeros((2, 1))
    alpha = 0.01
    num_iters = 2000
    m = y.shape[1]
    ones = np.ones((m, 1))
    X = np.hstack((ones, x.T))
    theta = descenso_del_gradiente(X, y, theta, alpha, num_iters)
    return theta

def graficar(x, y, theta):
    f = theta[1] * x + theta[0]
    fig, ax = plt.subplots(figsize=(12, 8))
    ax.plot(x[0, :], f[0, :], label="Predicción", color="green")
    ax.scatter(x[0, :], y[0, :], color="blue")
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.set_title("Predicción vs. Datos reales")
    plt.show()

if __name__ == "__main__":
    x = np.array([[1, 2, 3, 4, 5]])
    y = np.array([[4.5, 7.5, 8.5, 11.5, 12.5]])
    theta = regresion_lineal(x, y)
    print("Coeficientes de regresión theta:", theta)
    graficar(x, y, theta)