Qué es un vector: punto, flecha y lista de números

Si el álgebra lineal es el lenguaje del machine learning, el vector es su palabra más básica. Casi todo lo que toca un modelo —una fila de datos, un píxel, un embedding de texto, los pesos de una red neuronal— se representa como un vector. Antes de operar con ellos, necesitamos una intuición sólida de qué es un vector.

La idea clave de esta lección es que un vector admite tres lecturas equivalentes, y un buen practicante de ML salta entre las tres sin esfuerzo:

1. una lista ordenada de números (la visión computacional),
2. un punto en el espacio (la visión de los datos),
3. una flecha con magnitud y dirección desde el origen (la visión geométrica).

Las tres describen el mismo objeto. Elegimos la lectura más cómoda según lo que queramos hacer.

1. Un vector como lista ordenada de números

En su forma más concreta, un vector es simplemente una secuencia ordenada de números. "Ordenada" es la palabra importante: el primer número significa algo distinto del segundo, y no podemos reordenarlos sin cambiar el vector.

En notación matemática, un vector en el plano (dos números) se escribe en una columna:

$\mathbf{v} = \begin{bmatrix} 3 \\ 2 \end{bmatrix}$

Usamos negrita ($\mathbf{v}$) o una flechita ($\vec{v}$) para distinguir un vector de un número suelto (un escalar, como $5$ o $-1.4$). Cada número dentro se llama componente o coordenada: arriba la componente $v_1 = 3$, abajo $v_2 = 2$.

Decimos que este vector vive en $\mathbb{R}^2$ —el conjunto de todos los pares de números reales— porque tiene exactamente dos componentes reales.

import numpy as np

# Un vector es, en código, simplemente un arreglo 1-D de NumPy
v = np.array([3, 2])

print(v)            # [3 2]
print(v.shape)      # (2,)  -> dos componentes
print(v[0], v[1])   # 3 2   -> acceso por posición (el ORDEN importa)

2. Un vector como punto en el espacio

Si interpretamos las componentes como coordenadas, el vector $\mathbf{v} = \begin{bmatrix} 3 \\ 2 \end{bmatrix}$ marca un único punto en el plano: avanza $3$ a la derecha sobre el eje horizontal y $2$ hacia arriba sobre el eje vertical.

Esta es la lectura natural cuando pensamos en datos. Imagina un dataset de casas con dos columnas, superficie y precio. Cada casa es un punto en un plano superficie × precio, y todo el dataset es una nube de puntos. Ver los datos como puntos es lo que permite hablar de "distancia entre dos ejemplos", "agrupamientos" o "vecinos cercanos" más adelante.

3. Un vector como flecha (magnitud y dirección)

La tercera lectura, la más geométrica, dibuja una flecha desde el origen $(0,0)$ hasta el punto $(3, 2)$. Esta flecha tiene dos atributos:

• magnitud (longitud de la flecha), y
• dirección (hacia dónde apunta).

Esta visión es la que da sentido a operaciones como sumar vectores (encadenar flechas) o multiplicar por un escalar (estirar o encoger la flecha) —justo lo que veremos en la próxima lección. El gráfico de abajo muestra el mismo vector $\begin{bmatrix} 3 \\ 2 \end{bmatrix}$ como una flecha que parte del origen.

Las tres lecturas, lado a lado

El siguiente diagrama resume cómo un único objeto se mira de tres maneras. Da igual desde cuál partas: las tres describen exactamente el mismo vector.

De $\mathbb{R}^2$ a $\mathbb{R}^n$

Nada nos obliga a quedarnos en dos componentes. Un vector con $n$ componentes vive en $\mathbb{R}^n$ y se escribe de forma general:

$\mathbf{x} = \begin{bmatrix} x_1 \\ x_2 \\ \vdots \\ x_n \end{bmatrix}, \qquad x_i \in \mathbb{R}$

Con $n = 2$ o $n = 3$ podemos dibujarlo (plano y espacio). A partir de $n = 4$ ya no lo visualizamos, pero las matemáticas funcionan exactamente igual: sigue siendo una lista ordenada de números sobre la que sumamos, escalamos y medimos distancias. Y esto es crucial, porque en machine learning los vectores casi nunca son de dimensión 2: un embedding de texto puede tener $n = 768$ o más componentes. La intuición geométrica que construyes en $\mathbb{R}^2$ se transfiere a esas dimensiones altas aunque no puedas dibujarlas.

Por qué esto es el lenguaje del ML

Aquí está la conexión que hace que todo esto importe: en machine learning, los datos se representan como vectores.

• Una fila de datos es un vector. Si describes una persona por [edad, ingreso, años_de_estudio], ese ejemplo es un vector en $\mathbb{R}^3$. Un dataset entero es un montón de vectores apilados (una matriz, que veremos en el módulo 4).
• Un embedding es un vector. Los modelos modernos convierten una palabra, una frase o una imagen en un vector de cientos de dimensiones. Que dos textos "signifiquen algo parecido" se traduce en que sus vectores apuntan en direcciones parecidas —algo que mediremos con el producto punto y la similitud coseno en el módulo 3.
• Los parámetros de un modelo son vectores. Los pesos de una regresión lineal o de una capa de red neuronal forman un vector que el entrenamiento va ajustando.

En cuanto interiorizas que "fila de datos = punto = flecha = lista de números", frases como "calcula la distancia entre dos ejemplos" o "busca los embeddings más cercanos" dejan de ser jerga y se vuelven operaciones geométricas concretas.

import numpy as np

# Una fila de datos (un ejemplo) ES un vector.
# persona = [edad, ingreso_miles, anios_estudio]
persona = np.array([34, 52.0, 16])
print("Ejemplo en R^3:", persona, "-> shape", persona.shape)

# Un embedding es solo un vector con muchas mas componentes.
rng = np.random.default_rng(0)
embedding = rng.normal(size=768)        # vector en R^768
print("Embedding en R^768 -> shape:", embedding.shape)
print("Primeras 5 componentes:", embedding[:5].round(3))

Vector columna vs. vector fila

Un detalle de notación que vale la pena fijar desde ya, porque más adelante (al multiplicar por matrices) será importante: un vector puede escribirse en columna o en fila.

$\underbrace{\begin{bmatrix} 3 \\ 2 \end{bmatrix}}_{\text{columna } (2\times 1)} \qquad\text{vs.}\qquad \underbrace{\begin{bmatrix} 3 & 2 \end{bmatrix}}_{\text{fila } (1\times 2)}$

Matemáticamente representan la misma información; lo que cambia es su forma (shape): la columna es una matriz de $2\times 1$ y la fila una de $1\times 2$. Pasar de una a otra se llama transponer, y se nota con una $T$ pequeña:

$\mathbf{v} = \begin{bmatrix} 3 \\ 2 \end{bmatrix}, \qquad \mathbf{v}^{T} = \begin{bmatrix} 3 & 2 \end{bmatrix}$

Por convención matemática, cuando escribimos $\mathbf{v}$ sin más solemos referirnos a un vector columna. En NumPy, en cambio, lo más habitual y cómodo es un arreglo 1-D (shape (2,)) que no es ni fila ni columna: se adapta al contexto. Conviene saber distinguirlos para no llevarte sorpresas con las formas.

import numpy as np

v1d = np.array([3, 2])          # 1-D: ni fila ni columna, shape (2,)
print("1-D:", v1d.shape)

columna = v1d.reshape(2, 1)     # vector columna 2x1
fila    = v1d.reshape(1, 2)     # vector fila 1x2
print("columna shape:", columna.shape)
print("fila shape:   ", fila.shape)

# Transponer convierte una en la otra
print("columna.T shape:", columna.T.shape)   # (1, 2)
print(np.array_equal(columna.T, fila))        # True

Tu turno

Abre la idea con tus propios dedos antes de seguir:

1. Escribe en papel el vector $\mathbf{u} = \begin{bmatrix} -2 \\ 3 \end{bmatrix}$ como punto y como flecha desde el origen. ¿En qué cuadrante cae?
2. En NumPy, crea u = np.array([-2, 3]) y verifica su shape. Luego obtén su versión fila con u.reshape(1, 2).
3. Piensa en un objeto de tu trabajo o tu vida diaria que describirías con $4$ números. Acabas de inventar un vector en $\mathbb{R}^4$.

Puntos clave

• Un vector es un mismo objeto con tres lecturas equivalentes: lista ordenada de números, punto en el espacio y flecha con magnitud y dirección.
• El orden de las componentes importa; cada componente es una coordenada. Un escalar es solo un número suelto.
• Un vector de $n$ componentes vive en $\mathbb{R}^n$. A partir de $n = 4$ no lo dibujamos, pero opera igual; la intuición de $\mathbb{R}^2$ se transfiere.
• En ML, una fila de datos, un embedding y los parámetros de un modelo son vectores: por eso el álgebra lineal es su lenguaje.
• Un vector se puede escribir en columna ($n\times 1$) o en fila ($1\times n$); transponer ($\mathbf{v}^T$) pasa de una a otra. En NumPy lo natural es un arreglo 1-D.

En la próxima lección pondremos estas flechas a moverse: sumar vectores y multiplicarlos por un escalar, con NumPy y geometría.

Comprueba tu comprensión

Antes de seguir, verifica que las tres interpretaciones de un vector te quedaron claras: