Fundamentos matemáticos

1. ¿Qué es una variable y qué es una función?

Una variable es un símbolo que representa un valor que puede cambiar; una constante es un valor fijo. Una función $f$ toma una entrada $x$ y produce exactamente una salida $f(x)$. El conjunto de entradas válidas es el dominio y el de salidas posibles es el rango.

2. Funciones lineales y no lineales

Una función es lineal (afín) si tiene la forma $f(x)=mx+b$: su gráfica es una recta y $m$ es la pendiente. Cualquier otra forma es no lineal: cuadrática $x^2$, exponencial $e^x$, logarítmica $\log x$, sigmoide $\frac{1}{1+e^{-x}}$.

3. Exponenciales y logaritmos

La exponencial $e^x$ modela crecimiento multiplicativo. El logaritmo es su inversa:

Ejemplo numérico: $\log_2 1024 = 10$ porque $2^{10}=1024$. Y $\ln(e^3)=3$. Si una probabilidad es $p=0.001$, entonces $-\ln p \approx 6.91$: los sucesos improbables producen pérdidas grandes, idea central de la entropía cruzada.

4. Ecuaciones y sistemas

Resolver una ecuación es encontrar los valores que la satisfacen. Un sistema de dos ecuaciones lineales puede resolverse por sustitución o igualación.

En ML, los sistemas lineales aparecen al resolver mínimos cuadrados, al calcular estados estacionarios y en la formulación matricial de la regresión.

5. Aplicación en Machine Learning

Las transformaciones algebraicas preparan los datos. Si una variable como el ingreso tiene cola larga, aplicamos $\log(1+x)$ para comprimirla. Si queremos modelar probabilidades, usamos la función logística. La regresión lineal es literalmente una función afín de muchas variables:

6. Código Python

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-3, 3, 200)

lineal      = 2 * x + 1
cuadratica  = x ** 2
exponencial = np.exp(x)
sigmoide    = 1 / (1 + np.exp(-x))

print("log2(1024) =", np.log2(1024))
print("ln(e^3)    =", np.log(np.exp(3)))

# Resolver un sistema 2x2: 2x + 3y = 13 ; x - y = 1
A = np.array([[2, 3], [1, -1]])
b = np.array([13, 1])
sol = np.linalg.solve(A, b)
print("x, y =", sol)          # [3.2 2.2]

plt.figure(figsize=(8, 5))
plt.plot(x, lineal, label="2x + 1")
plt.plot(x, cuadratica, label="x^2")
plt.plot(x, sigmoide, label="sigmoide")
plt.ylim(-2, 8); plt.grid(alpha=.3); plt.legend()
plt.title("Funciones básicas usadas en ML")
plt.show()

Un vector es una lista ordenada de números. Puede representar un punto, una dirección o —lo más importante en ML— un conjunto de características de un ejemplo.

Operaciones básicas

• Suma: componente a componente. $\mathbf{u}+\mathbf{v}=(u_1+v_1,\dots,u_d+v_d)$.
• Escalar por vector: $c\mathbf{u}=(cu_1,\dots,cu_d)$; cambia la magnitud y, si $c<0$, el sentido.
• Producto punto: $\mathbf{u}\cdot\mathbf{v}=\sum_{i=1}^d u_iv_i$. Produce un escalar.
• Transpuesta: convierte un vector columna en fila: $\mathbf{x}^{\top}=(x_1,\dots,x_d)$.

Normas: cuánto mide un vector

Producto punto, ángulo y similitud

La similitud coseno es la base de la búsqueda semántica y de los sistemas de recomendación: dos documentos o embeddings son similares si el ángulo entre sus vectores es pequeño, sin importar su longitud.

Distancias que usarás en ML

Aplicación: embeddings y regularización

En NLP, cada palabra o token se representa como un vector denso. La similitud entre «gato» y «felino» se mide con coseno. En regularización, añadir $\lambda\|\mathbf{w}\|_2^2$ a la pérdida castiga pesos grandes; añadir $\lambda\|\mathbf{w}\|_1$ empuja muchos pesos exactamente a cero, produciendo modelos dispersos e interpretables.

import numpy as np

u = np.array([3.0, 4.0])
v = np.array([1.0, 2.0])

print("suma:", u + v)
print("escalar:", 2 * u)
print("producto punto:", np.dot(u, v))          # 11.0
print("norma L2 u:", np.linalg.norm(u))         # 5.0
print("norma L1 v:", np.abs(v).sum())           # 3.0
print("distancia:", np.linalg.norm(u - v))      # 2.828...

coseno = np.dot(u, v) / (np.linalg.norm(u) * np.linalg.norm(v))
print("similitud coseno:", coseno)              # 0.9838...

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-12)

# Embeddings ficticios de 4 dimensiones
gato   = np.array([0.2, 0.9, -0.1, 0.4])
felino = np.array([0.1, 0.8, -0.2, 0.5])
auto   = np.array([-0.7, 0.1, 0.8, -0.3])
print("gato~felino:", cosine_similarity(gato, felino))
print("gato~auto:  ", cosine_similarity(gato, auto))

Una matriz es una tabla rectangular de números. Si tiene $m$ filas y $n$ columnas, es de tamaño $m\times n$. En ML, una matriz de datos $X$ tiene una fila por ejemplo y una columna por característica.

Operaciones

Por qué importa el determinante

$\det(A)=0$ significa que las filas (o columnas) son linealmente dependientes: la matriz aplasta el espacio y no se puede invertir. Geométricamente, un determinante de 2 duplica áreas; de 0.5 las reduce a la mitad; negativo invierte la orientación.

Aplicación: regresión lineal en forma matricial

Con $X$ incluyendo una columna de unos para el intercepto, la solución de mínimos cuadrados es:

Una red neuronal es una secuencia de productos matriciales: $h=\sigma(Wx+b)$. Entrenar consiste en ajustar las entradas de $W$ y $b$.

import numpy as np

A = np.array([[2., 1.],
              [1., 3.]])
B = np.array([[1., 0.],
              [4., 2.]])

print("A @ B:\n", A @ B)
print("A^T:\n", A.T)
print("det(A):", np.linalg.det(A))       # 5.0
print("inv(A):\n", np.linalg.inv(A))
print("identidad:\n", A @ np.linalg.inv(A))

b = np.array([5., 10.])
x = np.linalg.solve(A, b)                # preferible a inv(A) @ b
print("solución:", x)                    # [1. 3.]

# Regresión lineal con la ecuación normal
X = np.array([[1., 1.], [1., 2.], [1., 3.], [1., 4.]])
y = np.array([2., 4., 5., 4.])
w = np.linalg.solve(X.T @ X, X.T @ y)
print("intercepto, pendiente:", w)       # [2.0, 0.7]

Los eigenvectores son direcciones especiales que una transformación lineal no rota: solo las estira o comprime. Los eigenvalores cuantifican cuánto. Esta idea es la base de PCA, de la estabilidad numérica y del análisis espectral.

Diagonalización

Si $A$ tiene $n$ eigenvectores linealmente independientes, podemos escribir $A=Q\Lambda Q^{-1}$, donde $Q$ tiene los eigenvectores como columnas y $\Lambda$ es diagonal con los eigenvalores. Para matrices simétricas, $Q$ es ortogonal ($Q^{-1}=Q^\top$).

Descomposición SVD

La Descomposición en Valores Singulares generaliza la diagonalización a cualquier matriz $m\times n$:

La SVD permite: comprimir imágenes (quedarse con los $k$ valores singulares mayores), resolver mínimos cuadrados de forma estable, calcular la pseudo-inversa y hacer reducción de dimensionalidad (PCA).

De eigenvalores a PCA

En PCA calculamos la matriz de covarianza $\Sigma$ de los datos centrados. Sus eigenvectores son las componentes principales y sus eigenvalores indican cuánta varianza explica cada dirección. La primera componente es la dirección de máxima varianza.

Si dos variables están muy correlacionadas, la covarianza tendrá un eigenvalor grande y otro pequeño; proyectar sobre el primero conserva casi toda la información con una sola dimensión.

import numpy as np

A = np.array([[2., 1.],
              [1., 2.]])

# Eigenvalores y eigenvectores
vals, vecs = np.linalg.eigh(A)     # eigh para matrices simétricas
print("eigenvalores:", vals)       # [1. 3.]
print("eigenvectores:\n", vecs)

# SVD
U, S, Vt = np.linalg.svd(A)
print("valores singulares:", S)    # [3. 1.]

# PCA manual sobre datos 2D
rng = np.random.default_rng(42)
X = rng.multivariate_normal([0, 0], [[3, 2.4], [2.4, 3]], size=200)
Xc = X - X.mean(axis=0)
cov = np.cov(Xc, rowvar=False)
vals, vecs = np.linalg.eigh(cov)
order = np.argsort(vals)[::-1]
vals, vecs = vals[order], vecs[:, order]
print("varianza explicada:", vals / vals.sum())

proyectado = Xc @ vecs[:, 0]       # 1D
print("forma original:", X.shape, "→ proyectada:", proyectado.shape)

La derivada mide cómo cambia una función cuando cambia su entrada. En ML, casi todo entrenamiento consiste en calcular derivadas de una función de pérdida y moverse en la dirección que la reduce.

Límites: la base conceptual

El límite $\lim_{x\to a}f(x)=L$ significa que $f(x)$ se acerca arbitrariamente a $L$ cuando $x$ se acerca a $a$. No importa qué ocurre exactamente en $x=a$.

Definición de derivada

Una derivada positiva indica crecimiento; negativa, decrecimiento; cero, un punto crítico (posible mínimo, máximo o punto de inflexión).

Reglas de derivación

Segunda derivada y curvatura

$f''(x)$ describe cómo cambia la pendiente. Si $f''(x)>0$, la función es convexa (curva hacia arriba) y un punto con $f'=0$ es un mínimo. Esta es la base de la optimización: las funciones de pérdida convexas tienen un único mínimo global.

Aplicación: derivada de la pérdida MSE

Para una predicción $\hat{y}=wx$ y un objetivo $y$, la pérdida cuadrática es $\ell(w)=\frac12(\hat{y}-y)^2=\frac12(wx-y)^2$. Su derivada respecto de $w$ es:

import numpy as np

def f(x):
    return 3 * x**2 + 2 * x - 5

def f_prima(x):
    return 6 * x + 2

# Aproximación numérica de la derivada (diferencias centrales)
def derivada_numerica(fn, x, h=1e-6):
    return (fn(x + h) - fn(x - h)) / (2 * h)

x0 = 1.0
print("f'(1) analítica:", f_prima(x0))          # 8
print("f'(1) numérica: ", derivada_numerica(f, x0))  # ≈ 8

# Descenso del gradiente para minimizar f(x) = 3x^2 + 2x - 5
x = 5.0
lr = 0.05
for i in range(30):
    grad = f_prima(x)
    x = x - lr * grad
print("mínimo aproximado:", x)   # ≈ -1/3
print("f(mínimo):", f(x))        # ≈ -5.333

Los modelos tienen muchos parámetros. La derivada parcial mide cómo cambia la pérdida al mover un solo parámetro, manteniendo los demás fijos. El gradiente reúne todas esas derivadas en un vector que apunta hacia el máximo crecimiento.

Derivada direccional

Si nos movemos en una dirección unitaria $\mathbf{u}$, la tasa de cambio es la proyección del gradiente:

Regla de la cadena

Es la herramienta que hace posible entrenar redes profundas. Si $z=f(y)$ e $y=g(x)$, entonces:

Ejemplo: $z=(3x+1)^2$. Sea $y=3x+1$; entonces $z=y^2$, $\frac{dz}{dy}=2y$ y $\frac{dy}{dx}=3$. Por tanto $\frac{dz}{dx}=6(3x+1)$.

Ejemplo multivariable: $z=x^2+y^2$ con $x=t$, $y=t^2$. Entonces $\frac{dz}{dt}=2x\cdot1+2y\cdot2t=2t+4t^3$.

Por qué el gradiente es la dirección de máximo crecimiento

Para un desplazamiento pequeño $\Delta\mathbf{x}$, la aproximación de primer orden es $f(\mathbf{x}+\Delta\mathbf{x})\approx f(\mathbf{x})+\nabla f^\top\Delta\mathbf{x}$. Si $\|\Delta\mathbf{x}\|$ es fijo, el producto punto se maximiza cuando $\Delta\mathbf{x}$ apunta en la dirección del gradiente. Por eso el negativo del gradiente es la dirección de descenso más rápido.

Derivadas que conviene memorizar

import numpy as np

def f(x):
    return x[0]**2 * x[1] + 3 * x[1]**2

def grad_f(x):
    x1, x2 = x
    return np.array([2 * x1 * x2, x1**2 + 6 * x2])

p = np.array([2.0, 1.0])
print("f:", f(p))              # 10
print("gradiente:", grad_f(p)) # [4. 10.]

# Comprobación numérica de las parciales
h = 1e-6
gx = (f(p + [h, 0]) - f(p - [h, 0])) / (2 * h)
gy = (f(p + [0, h]) - f(p - [0, h])) / (2 * h)
print("numérico:", np.array([gx, gy]))

El descenso del gradiente (gradient descent) es el algoritmo de optimización más importante de ML. La idea es simple: si estás en una ladera y quieres bajar, camina en la dirección de mayor descenso, da un paso pequeño y repite.

El papel de la tasa de aprendizaje

Variantes

• Batch gradient descent: usa todos los datos para calcular el gradiente. Estable, pero costoso.
• Stochastic gradient descent (SGD): usa un ejemplo por paso. Rápido y ruidoso; el ruido puede ayudar a escapar de mínimos locales.
• Mini-batch: usa 32–512 ejemplos. Es el compromiso estándar en la práctica.
• Momentum, RMSProp, Adam: adaptan la dirección o la magnitud del paso. Los veremos en el Módulo 7.

Convexidad: cuándo funciona bien

Si $L$ es convexa, todo mínimo local es global y el descenso del gradiente converge al óptimo con un $\eta$ adecuado. La regresión lineal con MSE y la regresión logística con entropía cruzada son convexas. Las redes neuronales no lo son: tienen muchos mínimos locales y puntos de silla, pero en la práctica el descenso estocástico encuentra soluciones útiles.

import numpy as np
import matplotlib.pyplot as plt

def f(x):
    return x**2

def grad(x):
    return 2 * x

def gradient_descent(x0=4.0, lr=0.2, steps=15):
    x = x0
    history = [x]
    for _ in range(steps):
        x = x - lr * grad(x)
        history.append(x)
        if abs(x) > 1e6:       # divergencia
            break
    return np.array(history)

for lr in [0.05, 0.2, 0.9, 1.05]:
    hist = gradient_descent(lr=lr, steps=12)
    print(f"lr={lr:<4} x_final={hist[-1]: .4e}  pasos={len(hist)-1}")

# Visualización de la trayectoria
lr = 0.2
hist = gradient_descent(lr=lr, steps=6)
xs = np.linspace(-1, 5, 200)
plt.plot(xs, f(xs), label="f(x)=x²")
plt.scatter(hist, f(hist), c=range(len(hist)), cmap="viridis", zorder=3)
plt.plot(hist, f(hist), "--", alpha=.5)
plt.xlabel("x"); plt.ylabel("f(x)"); plt.legend(); plt.grid(alpha=.3)
plt.show()

La probabilidad es el lenguaje de la incertidumbre. Un modelo de ML casi nunca está seguro: estima probabilidades, distribuciones y riesgos. Este tema introduce los axiomas, la probabilidad condicional y el teorema que gobierna la inferencia bayesiana.

Experimento, espacio muestral y eventos

• Experimento aleatorio: proceso cuyo resultado no se puede predecir con certeza (lanzar un dado).
• Espacio muestral $\Omega$: conjunto de todos los resultados posibles. Para un dado, $\Omega=\{1,2,3,4,5,6\}$.
• Evento $A$: subconjunto de $\Omega$. «Salir par» es $A=\{2,4,6\}$.
• Probabilidad $P(A)$: número entre 0 y 1 que cuantifica la verosimilitud de $A$.

Axiomas de Kolmogorov

Probabilidad condicional e independencia

$A$ y $B$ son independientes si $P(A\cap B)=P(A)P(B)$, equivalentemente $P(A\mid B)=P(A)$: saber que ocurrió $B$ no aporta información sobre $A$.

Teorema de Bayes

Aplicación en ML

Naive Bayes aplica exactamente esta regla suponiendo independencia condicional de las features dada la clase:

La inferencia bayesiana también aparece en la calibración de probabilidades, en los modelos jerárquicos y en la optimización bayesiana de hiperparámetros.

# Teorema de Bayes: prueba médica
p_enf = 0.01
sensibilidad = 0.99      # P(+ | enfermo)
especificidad = 0.95     # P(- | sano)

p_pos_dado_enf = sensibilidad
p_pos_dado_sano = 1 - especificidad
p_pos = p_pos_dado_enf * p_enf + p_pos_dado_sano * (1 - p_enf)

p_enf_dado_pos = p_pos_dado_enf * p_enf / p_pos
print(f"P(enfermo | positivo) = {p_enf_dado_pos:.4f}")   # 0.1667

# Simulación Monte Carlo para verificar
import numpy as np
rng = np.random.default_rng(0)
n = 1_000_000
enfermos = rng.random(n) < p_enf
positivos = np.where(enfermos,
                     rng.random(n) < sensibilidad,
                     rng.random(n) < p_pos_dado_sano)
print("Monte Carlo:", enfermos[positivos].mean())

Una variable aleatoria es una función que asigna un número a cada resultado de un experimento. Nos permite describir el azar con funciones matemáticas y calcular esperanzas, varianzas y probabilidades.

Esperanza y varianza

Distribuciones fundamentales

La distribución normal

Si $X\sim\mathcal{N}(100,15^2)$ (CI clásico), la probabilidad de estar entre 85 y 115 es ≈68%. Estandarizando $Z=(X-\mu)/\sigma$, obtenemos $\mathcal{N}(0,1)$ y podemos usar tablas.

Aplicación: verosimilitud y pérdida

Si asumimos $y_i = \mathbf{w}^\top\mathbf{x}_i+\varepsilon_i$ con $\varepsilon_i\sim\mathcal{N}(0,\sigma^2)$, maximizar la verosimilitud equivale a minimizar la suma de errores al cuadrado:

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

# Dado justo
caras = np.arange(1, 7)
p = np.full(6, 1/6)
print("E[X] =", (caras * p).sum())          # 3.5
print("Var(X) =", (caras**2 * p).sum() - 3.5**2)  # 2.9167

# Normal
mu, sigma = 100, 15
x = np.linspace(40, 160, 300)
pdf = stats.norm.pdf(x, mu, sigma)
plt.plot(x, pdf, label="N(100, 15²)")
plt.fill_between(x, pdf, where=(x >= 85) & (x <= 115), alpha=.25, color="tab:green")
plt.title("68% de la masa entre μ ± σ")
plt.grid(alpha=.3); plt.legend(); plt.show()

print("P(85 < X < 115) =", stats.norm.cdf(115, mu, sigma) - stats.norm.cdf(85, mu, sigma))

# Binomial: 10 lanzamientos de moneda justa
print("P(X=5) =", stats.binom.pmf(5, 10, 0.5))   # 0.2461

# Muestreo de una normal
rng = np.random.default_rng(42)
muestra = rng.normal(loc=mu, scale=sigma, size=10_000)
print("media muestral:", muestra.mean(), "sd muestral:", muestra.std(ddof=1))

La estadística nos permite describir datos y, más importante, generalizar desde una muestra a una población. Sin ella, no podemos saber si una mejora de accuracy del 1% es real o ruido.

Medidas de tendencia central

Dispersión

Correlación y covarianza

Ejemplo: $x=(1,2,3)$, $y=(2,4,5)$. $\operatorname{Cov}=1.5$ (muestral), $s_x=1$, $s_y\approx1.528$, luego $r\approx0.982$: relación lineal positiva casi perfecta.

Muestreo y teorema central del límite

Una muestra aleatoria es indispensable para que las inferencias sean válidas. Si tomamos una muestra sesgada (por ejemplo, solo usuarios activos), ninguna técnica estadística repara el sesgo.

Intervalos de confianza

Interpretación correcta: si repitiéramos el muestreo muchas veces, el 95% de los intervalos construidos así contendrían el verdadero $\mu$. No significa «hay 95% de probabilidad de que $\mu$ esté en este intervalo concreto».

Pruebas de hipótesis

1. Formular $H_0$ (hipótesis nula) y $H_1$ (alternativa).
2. Elegir un estadístico y un nivel de significancia $\alpha$ (típicamente 0.05).
3. Calcular el estadístico y el valor $p$.
4. Rechazar $H_0$ si $p<\alpha$; en caso contrario, no rechazar (no «aceptar»).

Aplicación en evaluación de modelos

Cuando comparas dos modelos, una diferencia de 0.01 en accuracy puede ser ruido. Usa validación cruzada, reporta media y desviación estándar de las métricas, y aplica pruebas pareadas (por ejemplo, t-test sobre los folds o McNemar para clasificación). Un intervalo de confianza te dice cuánto puede variar el rendimiento en producción.

import numpy as np
from scipy import stats

datos = np.array([2, 4, 4, 4, 5, 5, 7, 9])
print("media:", datos.mean())          # 5.0
print("mediana:", np.median(datos))    # 4.5
print("var muestral:", datos.var(ddof=1))
print("sd muestral:", datos.std(ddof=1))

x = np.array([1, 2, 3])
y = np.array([2, 4, 5])
print("correlación:", np.corrcoef(x, y)[0, 1])   # ≈ 0.982

# IC 95% para la media
n = 25
media, s = 52, 10
t_crit = stats.t.ppf(0.975, df=n-1)
margen = t_crit * s / np.sqrt(n)
print(f"IC 95%: [{media - margen:.2f}, {media + margen:.2f}]")

# Prueba t
t_stat, p_val = stats.ttest_1samp(np.random.default_rng(7).normal(52, 10, n), 50)
print(f"t={t_stat:.3f}, p={p_val:.3f}")