Escalares, vectores y tensores en Machine Learning

Comprender cómo representar datos con escalares, vectores, matrices y tensores es clave para preparar información en Machine Learning. Aquí verás, con ejemplos en Google Colab y NumPy, cómo pasar del dato simple a estructuras que alimentan modelos reales, además de visualizar con Matplotlib.

¿Cómo pasar de un escalar a un vector con NumPy?

Un escalar es un número único: precio, edad o metros cuadrados. Un vector es una lista ordenada de escalares que describe un objeto completo: por ejemplo, una casa con metros cuadrados, habitaciones y precio. En código, crear el vector producto A en NumPy se hace con un array.

• Un vector se ve en NumPy como un array de una dimensión.
• Sus atributos ndim, shape y size revelan estructura y tamaño.
• Idea clave: el número de componentes del vector define el espacio geométrico donde “vive”. Dos componentes: plano 2D. Tres componentes: espacio 3D. En producción, los vectores pueden tener cientos o millones de dimensiones.

¿Qué significan ndim, shape y size?

• ndim: cantidad de ejes del array. Un vector tiene 1.
• shape: tupla con la forma. Para un vector con 2 elementos: (2,).
• size: número total de elementos. Aquí: 2.

import numpy as np

producto_A = np.array([20.0, 4.5])
print(f"vector producto: {producto_A}")

print(f"numero de ejes o dimensiones del producto: {producto_A.ndim}")
print(f"forma del producto: {producto_A.shape}")
print(f"numero total de elementos del producto: {producto_A.size}")

¿Cómo graficar un vector con Matplotlib?

Usa plt.quiver para dibujar una flecha desde el origen hasta los componentes x e y del vector. Etiqueta ejes para dar contexto: precio en x y calificación en y.

import matplotlib.pyplot as plt

plt.figure(figsize=(6, 6))
plt.quiver(0, 0, producto_A[0], producto_A[1], angles='xy', scale_units='xy', scale=1, color='red')
plt.title('Producto A')
plt.xlabel('precio')
plt.ylabel('calificación')
plt.xlim(0, 25)
plt.ylim(0, 10)
plt.grid(True, alpha=0.3)
plt.show()

¿Cómo organizar conjuntos en matrices para machine learning?

Cuando los datos llegan en masa, pasamos de vectores a matrices: una colección de vectores apilados en filas y columnas. En ML seguimos una convención fundamental: filas son observaciones (usuarios, casas, pacientes) y columnas son características (edad, precio, altura). Por eso, el shape se lee como (observaciones, características), justo lo que esperan librerías como Scikit-learn.

• Ejemplo Netflix: una matriz de calificaciones con usuarios en filas y películas en columnas.
• ndim = 2: hay filas y columnas.
• shape = (4, 4): 4 observaciones por 4 características.
• size = 16: total de elementos.

calificaciones = np.array([
    [5, 1, 2, 0],
    [3, 2, 5, 1],
    [3, 2, 4, 5],
    [4, 4, 2, 2],
])

print(f"ndim: {calificaciones.ndim}")     # 2
print(f"shape: {calificaciones.shape}")   # (4, 4)
print(f"size: {calificaciones.size}")     # 16

¿Cómo indexar filas y columnas con slicing?

Selecciona una fila con índice. Selecciona una columna con : en filas y el índice de la columna.

# primera fila (usuario 1)
usuario_1 = calificaciones[0]
print(f"usuario 1: {usuario_1}")

# tercera columna (película 3)
pelicula_3 = calificaciones[:, 2]
print(f"pelicula 3: {pelicula_3}")

¿Qué es un tensor y cómo visualizarlo?

Una imagen a color tiene alto, ancho y profundidad de color. Para esto usamos un tensor: generaliza la matriz a tres o más dimensiones. Si un vector es 1D y una matriz 2D en NumPy, un tensor es 3D o más. Son el lenguaje nativo del deep learning (Tensorflow, Pytorch).

• Un píxel RGB combina tres canales: R (red), G (green) y B (blue), con valores de 0 a 255.
• Ejemplo: tensor con forma que se interpreta como “número de matrices internas, filas y columnas”.
• ndim = 3, shape con tres números y size como su multiplicación.

import numpy as np
import matplotlib.pyplot as plt

imagen_tensor = np.array([
    [[255,   0,   0], [  0, 255,   0], [  0,   0, 255]],
    [[125, 100,  40], [115,  80, 200], [ 30,  60,  90]],
])

print(f"ndim: {imagen_tensor.ndim}")
print(f"shape: {imagen_tensor.shape}")
print(f"size: {imagen_tensor.size}")

plt.imshow(imagen_tensor)
plt.title('imagen tensor')
plt.axis('off')
plt.show()

Te invito a comentar: comparte una matriz que crearías a partir de un problema real indicando qué representan sus filas y columnas, y si te animas, publica también la imagen que generes con tu tensor RGB