Multiplicación escalar para IA: aumenta, reduce o invierte un vector

Un vector de dirección puede indicar hacia dónde debe ir una actualización del modelo sin indicar qué tan grande debe ser el movimiento. Un solo número aporta esa segunda decisión. Si la dirección es $[4,-3]^\mathsf{T}$, multiplicarla por $0.25$ produce el movimiento más corto $[1,-0.75]^\mathsf{T}$. Multiplicarla por $-1$ conserva su longitud, pero apunta en la dirección contraria.

Ese número es un escalar: un valor que se aplica a cada coordenada. Al terminar esta lección podrás calcular productos escalar–vector, predecir su dirección y magnitud a partir del signo y el valor absoluto del escalar, implementarlos correctamente en NumPy y reconocer el mismo mecanismo dentro de una actualización escalada por la tasa de aprendizaje o de una contribución ponderada de un embedding.

Resultado de aprendizaje: Escalar un vector y predecir cambios en su dirección y magnitud.

La lección 15: Suma de vectores para la IA estableció que los vectores se combinan sumando las coordenadas correspondientes. La multiplicación escalar prepara uno de esos vectores antes de la suma: controla la intensidad con la que contribuye. El sitio web complementario oficial de Mathematics for Machine Learning introduce la multiplicación por un escalar en la sección 2.2 del libro. Los ejemplos, el código, el rayo interactivo, las aplicaciones de IA y las evaluaciones siguientes son originales.

Un número alcanza cada coordenada

Sea $\boldsymbol{v}\in\mathbb{R}^{n}$ un vector real con coordenadas $v_1,v_2,\ldots,v_n$, y sea $\alpha\in\mathbb{R}$ un escalar real. La letra griega $\alpha$ (alpha) solo es el nombre de un número; símbolos como $c$, $s$ o $\lambda$ podrían desempeñar el mismo papel.

La operación conserva la dimensión y el orden de las coordenadas del vector. Un escalar no añade una coordenada, no elige una coordenada ni mezcla coordenadas vecinas. Cambia los $n$ valores mediante la misma regla de multiplicación.

Una escala negativa invierte cada coordenada distinta de cero

Toma el vector de actualización

y elige $\alpha=-1.5$. El símbolo $\boldsymbol{u}$ nombra la actualización completa de tres coordenadas. Parte de la definición en lugar de intentar inferir la respuesta solo a partir del signo menos.

Este cálculo separa dos efectos. El valor absoluto —la distancia del escalar al cero— es $|\alpha|=1.5$, por lo que la magnitud del vector pasa a ser 1,5 veces su magnitud original. El signo negativo invierte su dirección. Ninguno de los dos efectos cambia qué característica o parámetro representa cada coordenada.

El signo elige el rayo; el valor absoluto el alcance

En dos dimensiones, dibuja $\boldsymbol{v}$ como una flecha desde el origen. Cada múltiplo escalar distinto de cero se encuentra en la misma recta infinita que pasa por esa flecha. Los escalares positivos ocupan el mismo rayo, los negativos el rayo opuesto y el cero colapsa la flecha en el origen.

En esta lección, magnitud significa la longitud euclidiana de la flecha. Para $\boldsymbol{v}=[v_1,\ldots,v_n]^\mathsf{T}$, define

El subíndice 2 distingue esta regla de longitud de otras reglas de magnitud que se estudiarán en una lección posterior. La multiplicación escalar cambia esta magnitud por $|\alpha|$, no por $\alpha$:

El valor absoluto es esencial porque una magnitud no puede ser negativa. El signo pertenece a la dirección; el valor absoluto, al tamaño.

Arrastra el escalar de abajo por los siete casos. El vector fijo es $\boldsymbol{v}=[4,-3]^\mathsf{T}$, cuya magnitud es $5$. La flecha escalada, la frase de estado y la tabla comienzan con el estado renderizado en el servidor $\alpha=1.5$ y se actualizan juntas cuando el componente se hace visible.

La imagen solo tiene dos dimensiones, pero la regla no. En un embedding de 768 coordenadas, un escalar sigue multiplicando las 768 coordenadas, y la magnitud sigue cambiando por $|\alpha|$ según la regla de longitud euclidiana.

Escalar antes de sumar controla una contribución

La multiplicación escalar resulta especialmente útil junto a la suma de vectores. Supón que un modelo tiene un estado de contexto

y una contribución candidata de embedding

Con un peso $\alpha=0.5$, escala primero y después suma:

El peso cambia la intensidad con la que $\boldsymbol{e}$ contribuye a esta suma. Un peso $0$ elimina esa contribución; un peso negativo contribuye en la dirección contraria. Este es el significado aritmético preciso de “intensidad del embedding”. No garantiza que la salida de una red neuronal completa cambie en proporción directa a $\alpha$: las transformaciones posteriores, la normalización y las operaciones no lineales pueden alterar el efecto posterior.

La regla distributiva explica por qué el escalado de una señal combinada se puede calcular antes o después de sumar sus partes:

En la coordenada $j$, ambos lados equivalen a $\alpha(v_j+w_j)=\alpha v_j+\alpha w_j$. Como todas las coordenadas coinciden, los vectores coinciden. La regla relacionada $(\alpha+\beta)\boldsymbol{v}=\alpha\boldsymbol{v}+\beta\boldsymbol{v}$ permitirá combinar varios vectores ponderados de forma eficiente en la próxima lección.

Una tasa de aprendizaje escala la dirección propuesta por un optimizador

Considera el paso más sencillo de descenso de gradiente estocástico (SGD), sin momentum ni weight decay. Sea $\boldsymbol{\theta}$ un vector de parámetros y $\boldsymbol{g}$ un vector gradiente que apunta hacia un aumento de la pérdida. Una tasa de aprendizaje positiva $\eta$ escala la dirección antes de restarla:

El cálculo diferencial necesario para obtener $\boldsymbol{g}$ aparece más adelante en el curso; por ahora, es un vector proporcionado cuya escala podemos inspeccionar directamente.

Esto es una multiplicación escalar seguida de la suma vectorial $\boldsymbol{\theta}+(-\eta\boldsymbol{g})$. La documentación actual de PyTorch SGD expresa el paso final de los parámetros de esta forma, después de cualquier modificación configurada de la dirección de actualización por weight decay, momentum o Nesterov. La precisión de esta afirmación importa: con esas opciones activadas, la tasa de aprendizaje puede escalar una dirección modificada, no el gradiente bruto sin tocar.

Para un pequeño paso numérico, sea

Entonces

Sustituir $\eta=0.25$ por $\eta=0.5$ duplicaría la magnitud de esta actualización propuesta, manteniendo su dirección. Ese hecho aritmético por sí solo no indica si una tasa de aprendizaje mayor mejora el entrenamiento o permanece estable; esas preguntas dependen de la superficie de pérdida y del comportamiento del optimizador, y corresponden al módulo de optimización posterior.

NumPy multiplica arrays; las listas de Python repiten

multiply de NumPy multiplica los argumentos elemento a elemento, y * es su abreviatura de operador para arrays. Las reglas de broadcasting de NumPy permiten que un escalar actúe sobre el array sin construir un array completo con escalares repetidos.

import numpy as np

vector = np.array([4.0, -3.0, 2.0])
alpha = -1.5

scaled_with_operator = alpha * vector
scaled_with_function = np.multiply(alpha, vector)

print("vector shape:", vector.shape)
print("operator result:", scaled_with_operator)
print("function result:", scaled_with_function)
print("same values:", np.array_equal(
    scaled_with_operator, scaled_with_function
))

La salida verificada es

vector shape: (3,)
operator result: [-6.   4.5 -3. ]
function result: [-6.   4.5 -3. ]
same values: True

Una lista normal de Python cambia el significado de *. La documentación de secuencias de Python define la multiplicación por un entero como repetición:

coordinates = [4.0, -3.0, 2.0]

print(2 * coordinates)
print(2 * np.array(coordinates))

[4.0, -3.0, 2.0, 4.0, -3.0, 2.0]
[ 8. -6.  4.]

El primer resultado tiene seis elementos y no es $2\boldsymbol{v}$. Convierte las coordenadas numéricas en un array de NumPy antes de usar aritmética de arrays. Un valor no entero como 0.5 * coordinates produce un TypeError en lugar de escalar los elementos.

El escalar ya tiene dos funciones: su signo elige si un vector distinto de cero conserva o invierte la dirección, y su valor absoluto controla la magnitud. Cuando se suman varios vectores escalados de este modo, la multiplicación escalar y la suma vectorial forman una combinación lineal: la construcción que impulsará la próxima lección.

Comprueba tu comprensión

3 * [1, -2]
# [1, -2, 1, -2, 1, -2]

import numpy as np

3 * np.array([1, -2])
# array([ 3, -6])