5. Operaciones Básicas con Vectores

Descripción de la cápsula

En esta cápsula vas a aprender las tres operaciones fundamentales con vectores: suma, resta y escalado. No vamos a entrar en álgebra lineal formal ni en multiplicación matricial; solo las operaciones básicas que te permiten entender cómo se manipulan y combinan vectores en AI.

Estas operaciones son la base de todo lo que viene: en semantic search, las queries se comparan con documentos (resta implícita para medir distancia); en manipulación de embeddings, puedes hacer operaciones como Vector("rey") - Vector("hombre") + Vector("mujer") ≈ Vector("reina") (suma y resta); en normalización, escalas vectores para que tengan magnitud 1.

Cuando termines, sabrás sumar, restar y escalar vectores (con intuición geométrica y ejemplos numéricos), y entenderás por qué esas operaciones son útiles en AI. Esta cápsula es 100% conceptual; no implementarás código, pero ganarás la intuición que necesitas para entender cómo los modelos de lenguaje manipulan embeddings internamente.

Suma de vectores

Definición:

Sumar dos vectores significa sumar sus coordenadas eje por eje.

Fórmula:

Vector A + Vector B = [a₁ + b₁, a₂ + b₂, ..., aₙ + bₙ]

Ejemplo en 2D:

Vector A = [3, 2]
Vector B = [1, 1]

A + B = [3+1, 2+1] = [4, 3]

Interpretación geométrica:

Sumar vectores es como combinar desplazamientos.

Visualización:

      ↑ Y
      |
    3 |         •(4,3) ← Resultado A+B
      |        ╱|
    2 |   •───╱ | ← B = [1,1]
      |   |╱    |
    1 | A |     |
      |   |     |
    0 •───────────────→ X
      0   1  2  3  4

Paso a paso:

1. Dibuja el vector A [3, 2] desde el origen
2. Desde el punto final de A (3, 2), dibuja el vector B [1, 1]
3. El resultado es el vector desde el origen hasta el punto final: [4, 3]

Analogía física: Si caminas 3 cuadras al este y 2 al norte (A), y luego 1 cuadra al este y 1 al norte (B), en total has caminado 4 cuadras al este y 3 al norte (A+B).

Ejemplo en 3D:

Vector A = [2, 3, 1]
Vector B = [1, -1, 2]

A + B = [2+1, 3+(-1), 1+2] = [3, 2, 3]

Interpretación: Combinar dos desplazamientos 3D. Si A te mueve a (2, 3, 1) y luego B te mueve (1, -1, 2) desde ahí, el desplazamiento total desde el origen es (3, 2, 3).

Propiedades de la suma:

1. Conmutativa: A + B = B + A

[3, 2] + [1, 1] = [4, 3]
[1, 1] + [3, 2] = [4, 3]

El orden no importa.

2. Asociativa: (A + B) + C = A + (B + C)

([3, 2] + [1, 1]) + [0, 2] = [4, 3] + [0, 2] = [4, 5]
[3, 2] + ([1, 1] + [0, 2]) = [3, 2] + [1, 3] = [4, 5]

Puedes agrupar en cualquier orden.

3. Elemento neutro: A + [0, 0] = A

[3, 2] + [0, 0] = [3, 2]

Sumar el vector cero no cambia nada.

Suma en alta dimensión:

Vector A (1536D): [0.23, -0.45, 0.12, ..., -0.34]
Vector B (1536D): [0.02, 0.05, -0.01, ..., 0.06]

A + B = [0.23+0.02, -0.45+0.05, 0.12+(-0.01), ..., -0.34+0.06]
      = [0.25, -0.40, 0.11, ..., -0.28]

Interpretación: Combinar dos "significados" en el espacio de 1536D. Por ejemplo, si A es el embedding de "rey" y B es un ajuste pequeño, A+B es un vector "cerca de rey" con alguna variación.

En AI: La suma de embeddings se usa para operaciones como:

• Combinar contextos (ej: documento + query)
• Ajustar embeddings (ej: embedding base + corrección)

Resta de vectores

Definición:

Restar dos vectores significa restar sus coordenadas eje por eje.

Fórmula:

Vector A - Vector B = [a₁ - b₁, a₂ - b₂, ..., aₙ - bₙ]

Ejemplo en 2D:

Vector A = [5, 3]
Vector B = [2, 1]

A - B = [5-2, 3-1] = [3, 2]

Interpretación geométrica:

Restar vectores da el desplazamiento desde B hasta A.

Visualización:

      ↑ Y
      |
    3 |          •A(5,3)
      |         ╱|
    2 |        ╱ | ← A-B = [3,2]
      |       ╱  |
    1 |   •──────| B(2,1)
      |
    0 •───────────────→ X
      0  1  2  3  4  5

Interpretación: A - B es el vector que va desde el punto B hasta el punto A.

Analogía: Si estás en (2, 1) (punto B) y quieres llegar a (5, 3) (punto A), el desplazamiento necesario es [3, 2] (A - B).

Ejemplo en 3D:

Vector A = [4, 5, 2]
Vector B = [1, 2, -1]

A - B = [4-1, 5-2, 2-(-1)] = [3, 3, 3]

Interpretación: Para ir de B a A, muévete 3 unidades en cada eje.

Usar resta para medir diferencia:

En AI, la resta se usa para calcular qué tan diferentes son dos vectores:

Vector "perro" = [0.23, -0.45, ..., -0.34]
Vector "gato"  = [0.25, -0.43, ..., -0.32]

Diferencia = perro - gato = [0.23-0.25, -0.45-(-0.43), ..., -0.34-(-0.32)]
           = [-0.02, -0.02, ..., -0.02]

Si la diferencia tiene valores muy pequeños (cercanos a 0), los vectores son muy similares.

Ejemplo famoso: Vector arithmetic

La operación más famosa en embeddings:

Vector("rey") - Vector("hombre") + Vector("mujer") ≈ Vector("reina")

Paso a paso:

1. Vector("rey") - Vector("hombre") = "realeza" sin género masculino
2. Sumar Vector("mujer") = "realeza" con género femenino
3. Resultado ≈ Vector("reina")

Interpretación: La resta captura "qué dirección en el espacio representa género". Luego sumas "mujer" para aplicar ese cambio a "rey".

Visualización simplificada (2D):

      Realeza ↑
              |
    "reina" • | • "rey"
              |
    "mujer" • | • "hombre"
              |───────────→ Género (masculino-femenino)

La "dirección género" es rey - hombre ≈ reina - mujer. Entonces rey - hombre + mujer ≈ reina.

Esto funciona porque los embeddings capturan relaciones geométricas. En alta dimensión (1536D), hay "direcciones" que representan conceptos como género, tamaño, tiempo, etc.

Escalado de vectores (multiplicación por escalar)

Definición:

Multiplicar un vector por un número (escalar) multiplica cada coordenada:

Fórmula:

k × Vector A = [k × a₁, k × a₂, ..., k × aₙ]

Ejemplo en 2D:

Vector A = [3, 2]
Escalar k = 2

2 × A = [2×3, 2×2] = [6, 4]

Interpretación geométrica:

Escalar un vector cambia su magnitud pero no su dirección.

Visualización:

      ↑ Y
      |
    4 |           •(6,4) ← 2×A (doble de largo)
      |          ╱
    2 |     •───╱ ← A = [3,2]
      |    ╱
    0 •───────────────→ X
      0  2  4  6

Interpretación:

• 2 × A apunta en la misma dirección que A (noreste)
• Pero tiene el doble de magnitud (el doble de largo)

Analogía: Si el vector A representa "caminar 3 pasos al este, 2 al norte", entonces 2 × A es "caminar 6 pasos al este, 4 al norte". Misma dirección, doble distancia.

Escalado con números negativos:

Vector A = [3, 2]
Escalar k = -1

-1 × A = [-3, -2]

Interpretación: Cambia a la dirección opuesta (de noreste a suroeste).

Visualización:

      ↑ Y
      |
    2 |     •(3,2) ← A
      |    ╱
    0 •───────────→ X
      | ╲
   -2 |  •(-3,-2) ← -A (opuesto)

Regla:

• k > 1: Alarga el vector (misma dirección, mayor magnitud)
• 0 < k < 1: Acorta el vector (misma dirección, menor magnitud)
• k = 0: Resultado es el vector cero [0, 0]
• k < 0: Invierte la dirección

Ejemplo en 3D:

Vector A = [2, 3, 1]
Escalar k = 0.5

0.5 × A = [0.5×2, 0.5×3, 0.5×1] = [1, 1.5, 0.5]

Interpretación: Vector con la mitad de magnitud, misma dirección.

Escalado en alta dimensión:

Vector A (1536D): [0.23, -0.45, 0.12, ..., -0.34]
Escalar k = 2

2 × A = [0.46, -0.90, 0.24, ..., -0.68]

Uso en AI: Escalar embeddings se usa para:

• Normalización: Hacer que todos los vectores tengan magnitud 1 (dividir por su magnitud)
• Ajustes de peso: Dar más o menos "importancia" a un embedding en combinaciones

Combinación de operaciones

Puedes combinar suma, resta y escalado en una sola expresión:

Ejemplo:

A = [3, 2]
B = [1, 1]
C = [0, 2]

Resultado = 2×A - B + 0.5×C
          = [6, 4] - [1, 1] + [0, 1]
          = [6-1+0, 4-1+1]
          = [5, 4]

Interpretación: Combinar múltiples desplazamientos con diferentes "pesos" (escalares).

En AI: Operaciones como esta se usan en modelos de lenguaje para combinar contextos con diferentes importancias:

final_context = 0.7 × document_embedding + 0.3 × query_embedding

Eso da más "peso" al documento que a la query en el embedding combinado.

Normalización: Hacer vectores unitarios

Normalización es escalar un vector para que su magnitud sea 1 (vector unitario).

Fórmula:

Vector normalizado = Vector / Magnitud(Vector)

Ejemplo en 2D:

Vector A = [3, 4]
Magnitud = √(3² + 4²) = √25 = 5

A normalizado = [3/5, 4/5] = [0.6, 0.8]

Comprobación: Magnitud([0.6, 0.8]) = √(0.36 + 0.64) = √1 = 1 ✓

Interpretación: El vector normalizado apunta en la misma dirección que A, pero tiene magnitud 1.

Visualización:

      ↑ Y
      |
    4 |       •A(3,4) ← Magnitud = 5
      |      ╱|
    3 |     ╱ |
      |    ╱  |
    2 |   ╱   |
      |  ╱    |
    1 | •(0.6,0.8) ← A normalizado, magnitud = 1
      |╱
    0 •───────────────→ X
      0  1  2  3

Ambos apuntan en la misma dirección (noreste), pero el normalizado tiene magnitud 1.

¿Por qué normalizar?

En AI, la normalización es crucial porque:

1. Elimina el efecto de la magnitud:

Si usas distancia euclidiana, vectores con mayor magnitud pueden sesgar los resultados. Normalizar hace que solo importe la dirección (similitud angular), no el "tamaño" del vector.

Ejemplo:

• Vector A = [3, 4] (magnitud = 5)
• Vector B = [6, 8] (magnitud = 10, misma dirección que A)

Sin normalizar, parecen diferentes (distancias distintas). Normalizados:

• A normalizado = [0.6, 0.8]
• B normalizado = [0.6, 0.8]

Son idénticos → misma dirección → perfectamente similares.

2. Estabilidad numérica:

En sistemas con millones de vectores, mantener magnitudes consistentes (todas = 1) evita problemas de overflow o underflow en cálculos.

3. Comparación con coseno:

Cuando usas similaridad coseno (que verás en Módulo 3), internamente se normaliza. Si pre-normalizas tus vectores, el coseno se reduce a un simple producto punto (más eficiente).

Fórmula de coseno:

cos(A, B) = (A · B) / (||A|| × ||B||)

Si A y B están normalizados (||A|| = ||B|| = 1):
cos(A, B) = A · B  (producto punto simple)

Por eso muchas bases de datos vectoriales (Pinecone, Weaviate) normalizan automáticamente los embeddings antes de guardarlos.

Operaciones en alta dimensión: Resumen práctico

Punto clave: Las operaciones funcionan exactamente igual en alta dimensión. Solo hay más coordenadas que procesar.

Ejercicios

Ejercicio 1: Suma de vectores 2D

Calcula:

a) [2, 3] + [1, -1]
b) [5, 0] + [0, 5]
c) [3, 2] + [-3, -2]

[2+1, 3+(-1)] = [3, 2]

[5+0, 0+5] = [5, 5]

[3+(-3), 2+(-2)] = [0, 0]

Ejercicio 2: Resta de vectores 2D

Calcula:

a) [5, 4] - [2, 1]
b) [0, 5] - [0, 2]
c) [3, 2] - [3, 2]

[5-2, 4-1] = [3, 3]

[0-0, 5-2] = [0, 3]

[3-3, 2-2] = [0, 0]

Ejercicio 3: Escalado de vectores

Calcula:

a) 3 × [2, 1]
b) 0.5 × [4, 6]
c) -1 × [3, 2]

[3×2, 3×1] = [6, 3]

[0.5×4, 0.5×6] = [2, 3]

[-1×3, -1×2] = [-3, -2]

Ejercicio 4: Normalización

Normaliza el vector [3, 4].

Magnitud = √(3² + 4²) = √(9 + 16) = √25 = 5

Vector normalizado = [3/5, 4/5] = [0.6, 0.8]

Magnitud([0.6, 0.8]) = √(0.36 + 0.64) = √1 = 1 ✓

Ejercicio 5: Combinación de operaciones

Calcula: 2 × [3, 1] - [1, 2] + 0.5 × [4, 0]

2 × [3, 1] = [6, 2]
[1, 2] = [1, 2]
0.5 × [4, 0] = [2, 0]

[6, 2] - [1, 2] + [2, 0]
= [6-1, 2-2] + [2, 0]
= [5, 0] + [2, 0]
= [7, 0]

Ejercicio 6: Vector arithmetic (conceptual)

Si en un espacio de embeddings:

Vector("rey") ≈ [10, 8]  (simplificado a 2D para ilustrar)
Vector("hombre") ≈ [5, 2]
Vector("mujer") ≈ [5, 8]

Calcula: Vector("rey") - Vector("hombre") + Vector("mujer") ≈ ?

[10, 8] - [5, 2] + [5, 8]
= [10-5, 8-2] + [5, 8]
= [5, 6] + [5, 8]
= [10, 14]

Troubleshooting

Problema 1: "No entiendo por qué A + B ≠ B + A visualmente"

Síntoma: Al dibujar A + B y B + A, te confundes porque parece que el orden importa.

Solución: El orden NO importa para el resultado final. Ambos dan el mismo vector resultante (mismo punto final), aunque el camino visual sea diferente:

A + B:
1. Dibuja A desde el origen
2. Desde el final de A, dibuja B
3. Llegas al punto final

B + A:
1. Dibuja B desde el origen
2. Desde el final de B, dibuja A
3. Llegas al mismo punto final

Analogía: Si caminas 3 cuadras al este y luego 2 al norte, llegas al mismo lugar que si caminas 2 al norte y luego 3 al este. El orden de los pasos no importa; el destino final es el mismo.

Problema 2: "¿Por qué A - B es diferente de B - A?"

Síntoma: Te confundes porque la resta NO es conmutativa.

Solución: A - B ≠ B - A (excepto si A = B).

Ejemplo:

• A - B = [5, 3] - [2, 1] = [3, 2] (desplazamiento de B a A)
• B - A = [2, 1] - [5, 3] = [-3, -2] (desplazamiento de A a B, opuesto)

Interpretación: A - B va "de B hacia A"; B - A va "de A hacia B" (dirección opuesta).

Regla: B - A = -(A - B) (vectores opuestos).

Problema 3: "¿Cuándo uso suma vs resta?"

Síntoma: No sabes cuándo usar cada operación.

Guía práctica:

Usa suma cuando:

• Quieras combinar dos vectores (ej: documento + query)
• Quieras acumular desplazamientos (ej: A + B + C)

Usa resta cuando:

• Quieras medir diferencia entre vectores (ej: distancia = ||A - B||)
• Quieras extraer una "dirección" conceptual (ej: rey - hombre = "realeza sin género masculino")

Problema 4: "¿Por qué normalizar si cambia las coordenadas?"

Síntoma: Temes perder información al normalizar.

Solución: La normalización solo cambia magnitud, no dirección. En muchas aplicaciones (ej: similaridad coseno), solo importa la dirección (qué tan parecidos son los vectores), no la magnitud.

Ejemplo:

• [3, 4] (magnitud = 5) y [6, 8] (magnitud = 10) tienen la misma dirección.
• Normalizados: ambos [0.6, 0.8] → idénticos.

Si lo que importa es "qué conceptos se parecen" (dirección), normalizar elimina ruido de magnitudes inconsistentes.

Cuándo NO normalizar: Si la magnitud tiene significado (ej: frecuencia de una palabra en TF-IDF), no normalices sin pensar. Pero en embeddings modernos (OpenAI, BERT), la magnitud suele ser ruido y se normaliza.

Conexión con semantic search

Las operaciones que viste aquí son la base de semantic search:

1. Generar embeddings (vectores 1536D):

Documento: "El perro es un animal doméstico"
→ Vector doc = [0.23, -0.45, ..., -0.34]

Query: "¿Qué animales son mascotas?"
→ Vector query = [0.25, -0.43, ..., -0.32]

2. Calcular diferencia (resta):

Diferencia = doc - query = [-0.02, -0.02, ..., -0.02]

Si la diferencia es pequeña (muchos valores cercanos a 0), los vectores son similares.

3. Calcular distancia (magnitud de la diferencia):

Distancia = ||doc - query|| = √((-0.02)² + (-0.02)² + ... + (-0.02)²)
          ≈ pequeña

Distancia pequeña → vectores cercanos → conceptos similares → documento relevante.

4. Normalizar (opcional):

Muchas bases de datos vectoriales normalizan automáticamente para que solo importe la dirección (similaridad angular, no distancia absoluta).

Resultado: El documento con menor distancia (o mayor coseno, que verás en Módulo 3) es el más relevante para la query. Todo esto se basa en las operaciones que viste aquí (suma, resta, escalado).

Resumen

En una frase: Las operaciones básicas con vectores (suma = combinar, resta = diferencia, escalado = cambiar magnitud, normalización = hacer magnitud 1) funcionan igual en 2D, 3D y alta dimensión, y son la base de cómo se manipulan embeddings en AI.

Puntos clave:

• Suma: A + B = sumar coordenadas eje por eje → combinar desplazamientos
• Resta: A - B = restar coordenadas eje por eje → diferencia de B a A
• Escalado: k × A = multiplicar cada coordenada por k → cambiar magnitud, misma dirección
• Normalización: A / ||A|| = dividir por magnitud → vector con magnitud 1 (solo dirección importa)
• Propiedades: Suma es conmutativa y asociativa; resta NO es conmutativa
• Vector arithmetic: rey - hombre + mujer ≈ reina funciona por operaciones geométricas en alta dimensión
• Uso en AI: Combinar embeddings (suma), medir diferencia (resta), normalizar para comparación (escalado)
• Alta dimensión: Operaciones funcionan igual (solo más coordenadas que procesar)

Conexión con la siguiente cápsula

En la Cápsula 06 (Por qué vectores en AI), verás cómo todo lo que aprendiste (qué es un vector, visualización 2D/3D, alta dimensión, operaciones) se aplica específicamente en AI: por qué los modelos de lenguaje usan vectores para representar significado, cómo se entrenan embeddings, y por qué "vectores cercanos = significados similares" es la base de semantic search y RAG. Las operaciones de esta cápsula (suma, resta) son la base de manipulación de embeddings en modelos de lenguaje.

Recursos adicionales

1. 3Blue1Brown: "Linear combinations, span, and basis vectors" — Video de 10 min sobre combinaciones lineales (suma y escalado de vectores). Visualizaciones excelentes. En inglés.

2. Khan Academy: "Vector addition and subtraction" — Serie de videos cortos sobre suma y resta geométrica. En inglés con subtítulos.

3. Jay Alammar: "The Illustrated Word2vec" — Blog con diagramas sobre operaciones con embeddings (rey - hombre + mujer = reina). Excelente para ver operaciones en contexto real. En inglés.

4. DeepLearning.AI: "Vector Embeddings Visualized" — Recursos sobre visualización de embeddings y operaciones vectoriales en NLP. En inglés.

5. Pinecone: "Vector Operations" — Blog orientado a bases de datos vectoriales que explica operaciones comunes (suma, normalización, distancia). En inglés.

6. Better Explained: "Vector Calculus: Understanding the Dot Product" — Explicación intuitiva del producto punto (no cubierto en esta cápsula, pero útil para profundizar). En inglés.

Próxima cápsula: 06-why-vectors-in-ai.md — ¿Por qué los modelos de lenguaje usan vectores? Cómo se entrenan embeddings, por qué vectores cercanos = significados similares, y conexión directa con semantic search y RAG.