Vectores, matrices y tensores en NumPy

Curso de Álgebra Lineal para Machine Learning

Contenido del curso

No sé dónde empezar

Introducción al Álgebra Lineal para Machine Learning

Operaciones con Vectores y Matrices

Multiplicación de Matrices

Construcción de un Modelo de Regresión Lineal

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0020:26

Vectores, matrices y tensores en NumPy

Curso de Álgebra Lineal para Machine Learning

Clase 4 de 16

Clase 4 / 16

Recursos

Para que un modelo de machine learning pueda aprender, primero necesitas traducir el mundo real a un lenguaje que entienda. Ese lenguaje se construye con tres estructuras clave en NumPy: vectores, matrices y tensores, los bloques que describen desde un producto hasta una imagen a color.

Antes de entrar en código, conviene entender de dónde nacen estas estructuras. Todo empieza con el escalar, un único número como el precio de un producto, tu edad o los metros cuadrados de una casa [0:14]. Cuando agrupas varios escalares en una lista ordenada, obtienes un vector capaz de describir un objeto completo.

¿Qué es un vector y cómo lo representas en NumPy?

Un vector es una lista ordenada de escalares que describe un objeto por completo [0:35]. Para describir una casa, por ejemplo, usas un vector con tres componentes: metros cuadrados, número de habitaciones y precio.

En código se ve así, importando NumPy como np:

python import numpy as np

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

Este vector representa un producto de un e-commerce con dos características: precio (20 dólares) y calificación (4.5 estrellas) [1:30].

¿Cómo inspeccionas las propiedades de un vector?

NumPy ofrece tres atributos que te ayudan a diagnosticar cualquier array:

ndim: número de ejes o dimensiones de la estructura.
shape: forma del array, expresada como una tupla.
size: número total de elementos.

Al ejecutar estos atributos sobre producto_A, obtienes ndim = 1, shape = (2,) y size = 2 [3:00]. Esto te dice que estás ante un array de una sola dimensión con dos elementos.

¿Cuántas dimensiones tiene un vector en machine learning? Depende de qué dimensión preguntes. Para NumPy, un vector siempre es un array de una dimensión. Pero geométricamente, el número de componentes define el espacio: dos componentes viven en un plano 2D, tres componentes en un espacio 3D [4:10].

Aquí está la idea que evita confusiones: una cosa es la estructura del array en NumPy y otra el espacio geométrico que ese vector representa. En plataformas como Netflix, los vectores de usuarios no tienen dos o tres componentes, sino cientos o millones, viviendo en espacios de altísima dimensión [4:50].

¿Cómo graficas un vector con matplotlib?

Para visualizar producto_A en un plano, usas quiver para dibujar una flecha desde el origen hasta las coordenadas del vector:

python 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()

El resultado muestra una flecha que llega hasta 20 en el eje de precio y 4.5 en el eje de calificación [6:30].

¿Qué es una matriz y por qué importan las filas y columnas?

Una matriz es una colección de vectores apilados que forman una tabla. En machine learning se sigue una convención fundamental que debes interiorizar:

Las filas son observaciones: cada fila es un ejemplo, como un usuario, una casa o un paciente.
Las columnas son características: cada columna es un atributo como edad, precio o altura.
La forma de una matriz se lee como (número de observaciones, número de características).

Esta estructura es la que esperan la mayoría de modelos en librerías como Scikit-Learn [7:40].

¿Cómo construyes y exploras una matriz tipo Netflix?

Imagina una matriz de calificaciones donde las filas son usuarios y las columnas son películas:

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

Al inspeccionarla, obtienes ndim = 2, shape = (4, 4) y size = 16 [9:30]. Dos ejes, cuatro filas, cuatro columnas y 16 elementos en total.

Para extraer información puntual usas slicing. Si quieres las calificaciones del primer usuario, accedes con un índice; si quieres todas las calificaciones de una película, usas dos puntos:

python calificaciones_usuario_1 = calificaciones[0] calificaciones_pelicula_3 = calificaciones[:, 2]

Los dos puntos antes de la coma significan todas las filas, y el 2 después de la coma selecciona la tercera columna [11:20].

¿Qué es un tensor y para qué sirve?

Un tensor es la generalización de una matriz a tres o más dimensiones. Si un vector es 1D y una matriz es 2D para NumPy, un tensor empieza en 3D. Son el lenguaje nativo de librerías de deep learning como TensorFlow y PyTorch [12:30].

¿Cómo se representa un píxel con un tensor? Un píxel es la combinación de tres canales RGB (rojo, verde y azul), cada uno con un valor de 0 a 255. Una imagen con varios píxeles se modela como un tensor donde cada matriz interna representa un píxel con sus tres canales [13:00].

¿Cómo creas y graficas un tensor de imagen?

Puedes pensar un tensor como una matriz de matrices. Cada matriz interna agrupa los canales RGB de un píxel:

python imagen_tensor = np.array([ [[255, 0, 0], [0, 255, 0], [0, 0, 255]], [[125, 0, 0], [0, 100, 0], [40, 0, 115]] ])

Al inspeccionar, obtienes ndim = 3, shape = (2, 3, 3) y size = 18 [14:40]. El primer número del shape es la cantidad de matrices dentro del tensor, el segundo son las filas y el tercero las columnas.

Para visualizar la imagen usas imshow:

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

Verás dos píxeles renderizados: el primero con los canales RGB puros y el segundo con los valores aleatorios que definiste [15:50].

¿Cuál es la diferencia entre vector, matriz y tensor? El vector es una lista 1D de números que describe un objeto. La matriz es una tabla 2D de filas (observaciones) y columnas (características). El tensor es una estructura 3D o superior, ideal para imágenes, video o datos complejos.

Ahora te toca a ti: comparte en los comentarios una matriz que crearías a partir de un problema real, describiendo qué representan sus filas y sus columnas.

Jonathan De La Cruz

Hace 5 meses

Creando cubo Rubik

from mpl_toolkits.mplot3d.art3d import Poly3DCollection

#Creación del tensor

rubik = np.array([

[

[[52,65,255],[52,65,255],[52,65,255]],

], #Cara Azul

[

[[40,255,57],[40,255,57],[40,255,57]],

], #Cara Verde

[

[[255,30,30],[255,30,30],[255,30,30]],

], #Cara Roja

[

[[0,0,0],[0,0,0],[0,0,0]],

], #Cara Blanca

[

[[255,239,18],[255,239,18],[255,239,18]],

], #Cara Amarilla

[

[[255,140,0],[255,140,0],[255,140,0]],

], #Cara Naranja

], dtype=np.uint8)

print(f"Dimensiones: {rubik.ndim}")

print(f"filas x columnas: {rubik.shape}")

print(f"Numero de elementos: {rubik.size}")

# =========================

# Normalizar RGB (0-255 -> 0-1)

# matplotlib trabaja mejor así

# =========================

rubik = rubik / 255.0

# =========================

# Crear figura 3D

# =========================

fig = plt.figure(figsize=(8,8))

ax = fig.add_subplot(111, projection='3d')

# Tamaño de cada cuadrito

n = 3

# ==========================================================

# Función para dibujar una cara del cubo

# ==========================================================

def draw_face(face_colors, axis, fixed_value):

"""

face_colors -> matriz 3x3 RGB

axis:

'x' -> cara derecha

'y' -> cara frontal

'z' -> cara superior

fixed_value -> posición fija de la cara

"""

for i in range(n):

for j in range(n):

color = face_colors[i, j]

# Invertimos filas para que se vea natural

y = n - 1 - i

x = j

if axis == 'z':

verts = [[

[x, y, fixed_value],

[x+1, y, fixed_value],

[x+1, y+1, fixed_value],

[x, y+1, fixed_value]

]]

elif axis == 'y':

verts = [[

[x, fixed_value, y],

[x+1, fixed_value, y],

[x+1, fixed_value, y+1],

[x, fixed_value, y+1]

]]

elif axis == 'x':

verts = [[

[fixed_value, x, y],

[fixed_value, x+1, y],

[fixed_value, x+1, y+1],

[fixed_value, x, y+1]

]]

square = Poly3DCollection(

verts,

facecolors=[color],

edgecolors='black',

linewidths=2

)

ax.add_collection3d(square)

# ======================================

# Dibujar 3 caras visibles

# ======================================

# Cara superior

draw_face(rubik[0], axis='z', fixed_value=3)

# Cara frontal

draw_face(rubik[1], axis='y', fixed_value=0)

# Cara derecha

draw_face(rubik[2], axis='x', fixed_value=3)

# =========================

# Configuración visual

# =========================

ax.set_xlim(0,3)

ax.set_ylim(0,3)

ax.set_zlim(0,3)

ax.set_box_aspect([1,1,1])

# Vista en perspectiva

ax.view_init(elev=25, azim=-45)

# Ocultar ejes

ax.set_axis_off()

plt.title("Cubo Rubik 3D usando Tensores RGB")

plt.show()

Comentarios (28)28 comentarios

Jhon Alexander García Sierra

Hace 9 meses

Daniel Erazo

Profesor

Juan Pablo Marin Jimenez

Gabriel Obregón

Hace 10 meses

José Eder Guzmán Mendoza

Hace 7 meses

ANDRES FELIPE ATEHORTUA GAVIRIA

Hace 4 meses

Franco Alvarado

Hace 6 meses

Victor Alfonso Anaya Pineda

Victor R. M Cárdenas.

Chaparro Rojas Jeferson Arley

Gabriel Londoño

William Alexander Bejarano Pinilla

Alex Xiomar Rubio Lopez

Carlos Alvarado Riaño

Daniela Estupiñan

NESTOR IVAN RONCANCIO CABALLERO

Hace 8 meses

Orlando mendez

Manuel De los Reyes

Teth Azrael Cortes Aguilar

Darlinson Felipe Polania Camacho

Luis Felipe Rodríguez Zamora

Introducción al Álgebra Lineal para Machine Learning

Álgebra lineal detrás de Spotify y Netflix

Configura Google Colab para álgebra lineal

NumPy y Matplotlib para datos en Python

Vectores, matrices y tensores en NumPy

Operaciones con Vectores y Matrices

Resta y broadcasting de vectores en NumPy

Norma L2 vs L1 en vectores con NumPy

Similitud coseno con vectores de palabras

Ortogonalidad y ortonormalidad con NumPy

Multiplicación de Matrices

Producto matriz-vector para inferencia en NumPy

Multiplicación matricial en redes neuronales

Matriz identidad e inversa en NumPy

Construcción de un Modelo de Regresión Lineal

Regresión lineal desde cero con álgebra lineal

Regresión lineal resuelta con álgebra lineal

Determinante y rango para diagnosticar matrices

Multicolinealidad: por qué rompe tu modelo

Pseudo inversa de NumPy para matrices singulares

Vectores, matrices y tensores en NumPy

Progreso del curso

Introducción al Álgebra Lineal para Machine Learning

Operaciones con Vectores y Matrices

Multiplicación de Matrices

Construcción de un Modelo de Regresión Lineal

Recursos

Recursos