Vectores

Los vectores son estructuras fundamentales en el aprendizaje automático. En esta sección abordaremos vectores desde una descripción matemática.

Concepto

El concepto de "Vector" es ambiguo, ya que puede referirse al menos a 3 conceptos relacionados.

Vector en programación

El concepto de vector es ampliamente conocido en programación, especialmente en lenguajes como C, C++ y Java. Ya que el se puede referir a una colección de datos de un mismo tipo, tambien conocido como array o arreglo. En este sentido, un vector es una colección de datos de un mismo tipo, ordenados en una secuencia lineal.

Podemos definir un vector en un lenguaje de programacion de la siguiennte manera:

public class VectorExample {
  public static void main(String[] args) {
      int[] vector = {1, 2, 3, 4, 5};
      
      // Imprimir cada elemento del vector
      for (int i = 0; i < vector.length; i++) {
          System.out.println("vector[" + i + "] = " + vector[i]);
      }
  }
}

Vector en física

En física, un vector es una magnitud que posee tres características fundamentales:

• Magnitud (o módulo): el valor numérico de la cantidad.
• Dirección: la línea de acción sobre la que actúa.
• Sentido: la orientación a lo largo de esa línea.

Por ejemplo, una velocidad de $10 \, \text{m/s}$ hacia el noroeste es un vector, ya que no solo indica cuánto (magnitud), sino también hacia dónde (dirección y sentido).

Veamos cada una con calma.

Magnitud (o módulo):

La magnitud indica qué tan grande es el vector. Es un valor numerico acompañado de una unidad de medida.

Por ejemplo:

• 10 m/s
• 5 N (Newtons)
• 20 km/h

En el ejemplo de la figura 1, una velocidad de 10 m/s tiene una magnitud de 10.

La magnitud responde a la pregunta: "¿Cuánto"? pero por si sola no es suficiente para describir un vector fisico.

Dirección:

La dirección indica la linea sobre la cual actúa el vector.

En el plano, esta dirección suele describirse mediante puntos cardinales (norte, sur, este, oeste) o mediante un ángulo (45°, 90°, 180°, 270°)

Sentido:

El sentido indica hacia qué lado de la dirección apunta el vector.

Por ejemplo:

• Norte vs sur
• Este vs oeste

Dos vectores pueden tener la misma magnitud y dirección, pero diferente sentido.

Representación matemática de un vector

Ahora que entendemos qué es un vector en física, veamos cómo podemos representarlo con números.

Imagina un plano con dos ejes: uno horizontal (eje $x$) y otro vertical (eje $y$). Cualquier punto en este plano se puede describir con dos números: cuánto avanzamos en horizontal y cuánto en vertical.

Un vector funciona igual. En lugar de decir "10 m/s hacia el noroeste", podemos expresarlo con dos componentes:

• Componente $x$: cuánto avanza en horizontal
• Componente $y$: cuánto avanza en vertical

Escribimos esto así:

Por ejemplo, el vector de la Figura 1 (10 m/s a 135°) se puede escribir como:

El valor negativo en $x$ indica que va hacia la izquierda, y el positivo en $y$ indica que va hacia arriba.

Operaciones con vectores

Antes de ver el ejemplo práctico, necesitamos aprender tres operaciones básicas. No te preocupes, son muy sencillas.

1. Suma de vectores

Sumar dos vectores es tan simple como sumar sus componentes por separado:

Ejemplo: Si tenemos $\vec{a} = (3, 2)$ y $\vec{b} = (1, 4)$:

Piénsalo así: si caminas 3 pasos a la derecha y 2 hacia arriba, y luego 1 paso a la derecha y 4 hacia arriba, en total caminaste 4 pasos a la derecha y 6 hacia arriba.

2. Multiplicar por un número (escalar)

Cuando multiplicamos un vector por un número, multiplicamos cada componente:

Ejemplo: Si $\vec{v} = (2, 3)$ y lo multiplicamos por 2:

Esto "estira" el vector al doble de su tamaño original.

3. Calcular la magnitud

¿Recuerdas la magnitud? Es el "tamaño" del vector. Para calcularla usamos el teorema de Pitágoras:

Ejemplo: Si $\vec{v} = (3, 4)$:

¿Por qué importan estas operaciones?

En física, estas operaciones aparecen constantemente:

• Suma: cuando combinamos fuerzas o velocidades
• Escalar: cuando el tiempo afecta al movimiento (velocidad × tiempo = desplazamiento)
• Magnitud: cuando queremos saber "cuánto" se movió algo, sin importar la dirección

Con estas herramientas, ahora sí estamos listos para ver un ejemplo real.

Ejemplo práctico: Movimiento de un proyectil

Un ejemplo clásico de vectores en física es el movimiento de un proyectil. Cuando lanzamos un objeto (como una pelota), su movimiento se puede describir usando tres vectores:

• Posición $\vec{r}$: dónde está el objeto
• Velocidad $\vec{v}$: qué tan rápido y hacia dónde se mueve
• Aceleración $\vec{a}$: cómo cambia la velocidad (en este caso, la gravedad)

Implementación en Java utilizando Minerva

package com.minerva;
 
import com.minerva.core.primitives.Vector;
 
/**
* Simula un proyectil bajo la influencia de la gravedad.
* Utiliza vectores 2D para posición y velocidad.
*/
public class Projectile {
  private Vector position; // Posición actual [x, y]
  private Vector velocity; // Velocidad actual [vx, vy]
  private final Vector gravity; // Aceleración gravitacional [0, -g]
  private boolean hasLaunched; // Indica si el proyectil ya estuvo en el aire
 
  /**
   * Crea un nuevo proyectil con las condiciones iniciales dadas.
   *
   * @param initialPosition Vector de posición inicial [x, y]
   * @param initialVelocity Vector de velocidad inicial [vx, vy]
   */
  public Projectile(Vector initialPosition, Vector initialVelocity) {
      this.position = initialPosition;
      this.velocity = initialVelocity;
      // Gravedad hacia abajo: -9.81 m/s² en el eje Y
      this.gravity = new Vector(new double[] { 0, -9.81 });
      this.hasLaunched = false;
  }
 
  /**
   * Actualiza el estado del proyectil usando integración de Euler.
   * Retorna el paso de tiempo real usado (puede ser menor que dt si toca el suelo).
   *
   * @param dt Paso de tiempo en segundos
   * @return tiempo real transcurrido (puede ser menor si el proyectil tocó el suelo)
   */
  public double update(double dt) {
      double y0 = position.get(1);
 
      // Actualizar velocidad: v = v + a * dt
      velocity = velocity.add(gravity.scale(dt));
 
      // Actualizar posición: r = r + v * dt
      Vector newPosition = position.add(velocity.scale(dt));
      double y1 = newPosition.get(1);
 
      // Marcar como lanzado si sube por encima del suelo
      if (y1 > 0) {
          hasLaunched = true;
      }
 
      // Si ya fue lanzado y cruza el suelo, interpolar para encontrar y=0
      if (hasLaunched && y1 <= 0 && y0 > 0) {
          // Encontrar fracción del tiempo cuando y=0
          double fraction = y0 / (y0 - y1);
          double actualDt = dt * fraction;
 
          // Posición exacta en el impacto
          double xImpact = position.get(0) + velocity.get(0) * actualDt;
          position = new Vector(new double[] { xImpact, 0.0 });
 
          return actualDt;
      }
 
      position = newPosition;
      return dt;
  }
 
  /**
   * Retorna el vector de posición actual.
   */
  public Vector getPosition() {
      return position;
  }
 
  /**
   * Retorna el vector de velocidad actual.
   */
  public Vector getVelocity() {
      return velocity;
  }
 
  /**
   * Verifica si el proyectil ha tocado el suelo (y <= 0).
   */
  public boolean isOnGround() {
      return hasLaunched && position.get(1) <= 0;
  }
}

Resultado de la simulación

Al ejecutar el programa, veremos cómo el proyectil sube y luego cae por la gravedad:

Simulación de proyectil:
Velocidad inicial: [14.142135623730951, 14.14213562373095]
Magnitud: 20.0 m/s
t=0.0s  pos=[0.0, 0.0]  vel=[14.142135623730951, 14.14213562373095]
t=0.10s  pos=[1.41, 1.32]  vel=[14.14, 13.16]
t=0.20s  pos=[2.83, 2.53]  vel=[14.14, 12.18]
t=0.30s  pos=[4.24, 3.65]  vel=[14.14, 11.20]
t=0.40s  pos=[5.66, 4.68]  vel=[14.14, 10.22]
t=0.50s  pos=[7.07, 5.60]  vel=[14.14, 9.24]
t=0.60s  pos=[8.49, 6.43]  vel=[14.14, 8.26]
t=0.70s  pos=[9.90, 7.15]  vel=[14.14, 7.28]
t=0.80s  pos=[11.31, 7.78]  vel=[14.14, 6.29]
t=0.90s  pos=[12.73, 8.31]  vel=[14.14, 5.31]
t=1.00s  pos=[14.14, 8.75]  vel=[14.14, 4.33]
t=1.10s  pos=[15.56, 9.08]  vel=[14.14, 3.35]
t=1.20s  pos=[16.97, 9.32]  vel=[14.14, 2.37]
t=1.30s  pos=[18.38, 9.46]  vel=[14.14, 1.39]
t=1.40s  pos=[19.80, 9.50]  vel=[14.14, 0.41]
t=1.50s  pos=[21.21, 9.44]  vel=[14.14, -0.57]
t=1.60s  pos=[22.63, 9.29]  vel=[14.14, -1.55]
t=1.70s  pos=[24.04, 9.03]  vel=[14.14, -2.53]
t=1.80s  pos=[25.46, 8.68]  vel=[14.14, -3.52]
t=1.90s  pos=[26.87, 8.23]  vel=[14.14, -4.50]
t=2.00s  pos=[28.28, 7.68]  vel=[14.14, -5.48]
t=2.10s  pos=[29.70, 7.04]  vel=[14.14, -6.46]
t=2.20s  pos=[31.11, 6.29]  vel=[14.14, -7.44]
t=2.30s  pos=[32.53, 5.45]  vel=[14.14, -8.42]
t=2.40s  pos=[33.94, 4.51]  vel=[14.14, -9.40]
t=2.50s  pos=[35.36, 3.47]  vel=[14.14, -10.38]
t=2.60s  pos=[36.77, 2.34]  vel=[14.14, -11.36]
t=2.70s  pos=[38.18, 1.10]  vel=[14.14, -12.34]
t=2.78s  pos=[39.35, 0.00]  vel=[14.14, -13.33]
¡El proyectil tocó el suelo en 2.8 segundos!
Posición final: x=39.35 m, y=0.00 m

Observa cómo:

• La componente $x$ de la velocidad se mantiene constante (14.14 m/s)
• La componente $y$ de la velocidad disminuye por la gravedad (empieza positiva, termina negativa)
• La posición $y$ sube al principio y luego baja hasta llegar a 0

¿Qué demuestra este código?

1. Vectores como objetos: La clase Vector2D encapsula las componentes $(x, y)$ de un vector.

2. Operaciones vectoriales:

   • Suma: $\vec{v}_1 + \vec{v}_2 = (x_1 + x_2, y_1 + y_2)$
   • Producto escalar: $k \cdot \vec{v} = (k \cdot x, k \cdot y)$
   • Magnitud: $|\vec{v}| = \sqrt{x^2 + y^2}$

3. Física del movimiento:

   • La velocidad cambia debido a la aceleración: $\vec{v}_{nueva} = \vec{v} + \vec{a} \cdot \Delta t$
   • La posición cambia debido a la velocidad: $\vec{r}_{nueva} = \vec{r} + \vec{v} \cdot \Delta t$

4. Descomposición de vectores: La velocidad inicial se descompone en componentes usando:

   • $v_x = |\vec{v}| \cdot \cos(\theta)$
   • $v_y = |\vec{v}| \cdot \sin(\theta)$

Vector en matemáticas

Hasta ahora hemos visto vectores desde la física y la programación. Pero, ¿qué dice la matemática sobre ellos?

En matemáticas, un vector es simplemente una lista ordenada de números. Nada más, nada menos.

Estos números se llaman componentes del vector, y la cantidad de componentes define la dimensión del vector.

Ejemplos de vectores por dimensión

No te preocupes si no puedes "imaginar" un vector de 100 dimensiones. Nadie puede. Pero matemáticamente funciona exactamente igual que uno de 2D.

El producto punto: medir similitud entre vectores

Hay una operación muy importante que aún no hemos visto: el producto punto (también llamado producto escalar o producto interno).

Dados dos vectores $\vec{a}$ y $\vec{b}$:

Es decir, multiplicamos componente a componente y sumamos todo.

Ejemplo: Si $\vec{a} = (1, 2, 3)$ y $\vec{b} = (4, 5, 6)$:

import com.minerva.core.primitives.Vector;
 
public class Main {
    public static void main(String[] args) {
 
        // Producto punto entre dos vectores
 
        Vector a = new Vector(new double[] { 1.0, 2.0, 3.0 });
        Vector b = new Vector(new double[] { 4.0, 5.0, 6.0 });
 
        double dotProduct = a.dot(b);
 
        System.out.println("Producto punto: " + dotProduct);
 
    }
}

Producto punto: 32.0

¿Para qué sirve?

El producto punto nos dice qué tan parecidos son dos vectores:

• Si el resultado es positivo y grande: los vectores apuntan en direcciones similares
• Si el resultado es cercano a cero: los vectores son perpendiculares (no tienen nada que ver)
• Si el resultado es negativo: los vectores apuntan en direcciones opuestas

Esto es muy útil en machine learning para comparar cosas.

Normalizando un vector

A veces queremos que un vector tenga magnitud 1, sin cambiar su dirección. A esto se le llama normalizar el vector.

Para normalizar, dividimos cada componente entre la magnitud:

El vector resultante $\hat{v}$ (llamado "vector unitario") siempre tiene magnitud 1.

Ejemplo: Normalizar $\vec{v} = (3, 4)$:

1. Calcular magnitud: $|\vec{v}| = \sqrt{3^2 + 4^2} = \sqrt{25} = 5$
2. Dividir: $\hat{v} = \left( \frac{3}{5}, \frac{4}{5} \right) = (0.6, 0.8)$

Verificación: $\sqrt{0.6^2 + 0.8^2} = \sqrt{0.36 + 0.64} = \sqrt{1} = 1$ ✓

Ejemplo de Machine Learning: Clasificador simple

Ahora veamos cómo se usan los vectores en inteligencia artificial.

El problema

Imagina que tienes datos de flores con dos medidas:

• Largo del pétalo (en cm)
• Ancho del pétalo (en cm)

Quieres clasificar si una flor es de tipo A o tipo B.

La idea

Cada flor se puede representar como un vector 2D:

Por ejemplo:

• Flor 1: $(5.1, 1.8)$ → Tipo A
• Flor 2: $(1.4, 0.2)$ → Tipo B
• Flor 3: $(4.7, 1.5)$ → Tipo A

El clasificador más simple: comparar con promedios

1. Calculamos el vector promedio de cada tipo
2. Para una flor nueva, vemos a cuál promedio está más cerca

Paso 1: Calcular promedios

Si las flores tipo A son $(5.1, 1.8)$ y $(4.7, 1.5)$:

Si las flores tipo B son $(1.4, 0.2)$ y $(1.3, 0.3)$:

Paso 2: Clasificar una flor nueva

Tenemos una flor nueva: $(4.5, 1.6)$. ¿Es tipo A o B?

Calculamos la distancia a cada promedio usando la magnitud de la diferencia:

Como $0.40 < 3.42$, la flor está más cerca del promedio A.

Resultado: Tipo A ✓

Implementación en Java

package com.minerva;
 
import com.minerva.core.primitives.Vector;
 
/**
* Clasificador simple de flores basado en distancia euclidiana.
* Usa vectores para representar características y centroides.
*/
public class FlowerClassifier {
  private Vector centroidA; // Promedio de flores tipo A
  private Vector centroidB; // Promedio de flores tipo B
 
  /**
   * Entrena el clasificador con datos de ejemplo.
   */
  public void train(Vector[] tipoA, Vector[] tipoB) {
      this.centroidA = calculateCentroid(tipoA);
      this.centroidB = calculateCentroid(tipoB);
  }
 
  /**
   * Calcula el centroide (promedio) de un conjunto de vectores.
   */
  private Vector calculateCentroid(Vector[] flowers) {
      int n = flowers.length;
      int dimensions = flowers[0].size();
      
      // Sumar todos los vectores
      Vector sum = new Vector(new double[dimensions]);
      for (Vector flower : flowers) {
          sum = sum.add(flower);
      }
      
      // Dividir entre n para obtener el promedio
      return sum.scale(1.0 / n);
  }
 
  /**
   * Clasifica una flor nueva.
   * Retorna "A" o "B" según qué centroide esté más cerca.
   */
  public String classify(Vector flower) {
      // Calcular distancia a cada centroide
      double distA = flower.subtract(centroidA).norm();
      double distB = flower.subtract(centroidB).norm();
 
      // Retornar el tipo más cercano
      return distA < distB ? "A" : "B";
  }
 
  /**
   * Muestra información del clasificador.
   */
  public void printInfo() {
      System.out.println("Centroide A: " + centroidA);
      System.out.println("Centroide B: " + centroidB);
  }
}

Resultado

Centroide A: [4.9, 1.65]
Centroide B: [1.4, 0.2]
Flor [4.5, 1.6] -> Tipo A
Flor [1.2, 0.3] -> Tipo B
Flor [4.9, 1.4] -> Tipo A

¿Qué aprendimos?

1. Los datos son vectores: Cada flor es un vector con sus características
2. Entrenar = calcular promedios: El modelo "aprende" calculando el centroide de cada clase
3. Clasificar = medir distancias: Usamos la resta de vectores y la magnitud para comparar
4. Solo usamos operaciones básicas: Suma, resta, escalar y magnitud

Este es el algoritmo de clasificación más simple que existe, pero ilustra perfectamente cómo los vectores son la base del machine learning.

En la realidad, los vectores pueden tener cientos de dimensiones (imagina una flor descrita por 100 características) y los algoritmos son más sofisticados, pero la idea fundamental es la misma: convertir datos en vectores y hacer matemáticas con ellos.

Bonus: Definición formal de vectores

Hasta ahora hemos tratado a los vectores como "listas de números" o "flechas". Pero en matemáticas, la definición es mucho más abstracta y poderosa.

¿Qué es un campo?

Antes de definir vectores formalmente, necesitamos entender qué es un campo (en inglés: field).

Un campo $\mathbb{F}$ es un conjunto de elementos con dos operaciones (suma $+$ y multiplicación $\cdot$) que cumplen ciertos axiomas.

Axiomas de campo

Sea $\mathbb{F}$ un conjunto con operaciones $+$ y $\cdot$. Decimos que $(\mathbb{F}, +, \cdot)$ es un campo si para todo $a, b, c \in \mathbb{F}$:

Axiomas de la suma:

Axiomas de la multiplicación:

Axioma distributivo:

Ejemplos de campos

• $\mathbb{R}$ (números reales) ✓
• $\mathbb{Q}$ (números racionales) ✓
• $\mathbb{C}$ (números complejos) ✓
• $\mathbb{Z}$ (números enteros) ✗ (no tiene inverso multiplicativo para todos)

¿Qué es un espacio vectorial?

Ahora sí, la definición formal de espacio vectorial.

Sea $\mathbb{F}$ un campo. Un espacio vectorial sobre $\mathbb{F}$ es un conjunto $V$ junto con dos operaciones:

1. Suma de vectores: $+: V \times V \to V$
2. Producto por escalar: $\cdot: \mathbb{F} \times V \to V$

que satisfacen los siguientes 8 axiomas:

Axiomas del espacio vectorial

Para todo $\vec{u}, \vec{v}, \vec{w} \in V$ y todo $\alpha, \beta \in \mathbb{F}$:

Axiomas de la suma vectorial:

Axiomas del producto por escalar:

Definición formal de vector

Con todo esto, podemos dar la definición formal:

Definición: Un vector es un elemento de un espacio vectorial $V$ sobre un campo $\mathbb{F}$.

Esto significa que:

El espacio $\mathbb{R}^n$

El espacio vectorial que más usamos es $\mathbb{R}^n$: el conjunto de todas las $n$-tuplas de números reales.

Con las operaciones definidas componente a componente:

Suma:

Producto por escalar:

Se puede verificar que $\mathbb{R}^n$ cumple todos los axiomas V1-V9, por lo tanto es un espacio vectorial sobre $\mathbb{R}$.

¿Por qué importa esta definición?

La definición abstracta nos permite:

1. Generalizar: Cualquier conjunto que cumpla los axiomas es un espacio vectorial, no solo $\mathbb{R}^n$
2. Probar teoremas: Todo teorema probado para espacios vectoriales aplica a cualquier espacio que cumpla los axiomas
3. Espacios exóticos: Funciones, matrices, polinomios también pueden ser "vectores"

Ejemplos de espacios vectoriales no obvios

En todos estos casos, los "vectores" satisfacen los 8 axiomas, aunque no se parezcan a flechas ni a listas de números.

Conclusión

Lo que llamamos "vector" en programación (un array de números) es en realidad un elemento de $\mathbb{R}^n$, que es solo un ejemplo de espacio vectorial. La matemática abstracta nos da un marco teórico mucho más general.

Esta abstracción es lo que hace que el álgebra lineal sea tan poderosa: los mismos teoremas aplican a flechas en 3D, a imágenes de millones de píxeles, a funciones infinitas, y a sistemas de ecuaciones.