Fundamentos de NumPy ndarray para principiantes en Deep Learning: array, dtype, shape, reshape, astype

1. ¿Por qué empezar con ndarray?

Commandbox 광고

Al trabajar con deep learning, te encontrarás con estos fragmentos de código una y otra vez.

  • Revisar el shape del tensor de entrada
  • Usar reshape para crear batches
  • Convertir a float32 para operaciones en GPU…

La raíz de todo esto es el ndarray de NumPy.

  • El Tensor de PyTorch está basado casi idénticamente en el ndarray de NumPy
  • Los inputs, pesos y outputs de un modelo de deep learning son todos arrays multidimensionales (tensors)

Por lo tanto, entender bien el ndarray equivale a dominar la sintaxis básica de operaciones con tensores.

2. ¿Qué es un ndarray?

ndarray significa N-dimensional array, es decir, un “array de N dimensiones”.

  • 1D: vector
  • 2D: matriz
  • 3D o más: tensor (batch de imágenes, series temporales, video, etc.)

Ejemplo sencillo:

import numpy as np

x = np.array([1, 2, 3])            # 1D (vector)
M = np.array([[1, 2], [3, 4]])     # 2D (matriz)

print(type(x))          # <class 'numpy.ndarray'>
print(x.ndim, x.shape)  # número de dimensiones, forma
print(M.ndim, M.shape)
  • ndim: cuántas dimensiones tiene
  • shape: el tamaño de cada dimensión

3. ¿Cuánto se parece a un Tensor de PyTorch?

Commandbox 광고

Un tensor de PyTorch también es esencialmente un “array multidimensional”.

import torch

x_np = np.array([[1, 2], [3, 4]])   # NumPy ndarray
x_torch = torch.tensor([[1, 2], [3, 4]])  # PyTorch Tensor

print(type(x_np))      # numpy.ndarray
print(type(x_torch))   # torch.Tensor

print(x_np.shape)      # (2, 2)
print(x_torch.shape)   # torch.Size([2, 2])

Puntos en común:

  • Ambos son “arrays de números multidimensionales”
  • Conceptos como shape, reshape, dtype son prácticamente idénticos
  • Operaciones aritméticas (+, *, @, etc.) funcionan de forma similar

Diferencias clave (importantes en deep learning):

  • NumPy: CPU, sin autograd
  • PyTorch Tensor: GPU, autograd habilitado

Por eso se suele usar:

  • Conceptos, experimentos y manipulación de datos → NumPy
  • Entrenamiento real del modelo → PyTorch

Cuanto más familiarizado estés con ndarray, más natural será trabajar con tensores de PyTorch.

4. np.array: la forma básica de crear un ndarray

La función más básica para crear un ndarray es np.array.

4.1 Lista de Python → ndarray

import numpy as np

# Array 1D (vector)
x = np.array([1, 2, 3])
print(x)
print(x.ndim)   # 1
print(x.shape)  # (3,)

# Array 2D (matriz)
M = np.array([[1, 2, 3],
              [4, 5, 6]])
print(M)
print(M.ndim)   # 2
print(M.shape)  # (2, 3)
  • Una lista o lista de listas de Python se convierte en un ndarray con np.array.
  • La matriz batch_size x feature_dim que ves en deep learning es simplemente este patrón.

4.2 Crear arrays con valores iniciales rápidamente

En ejemplos de entrenamiento o experimentos, a menudo necesitas arrays llenos de ceros o aleatorios.

zeros = np.zeros((2, 3))       # 2x3 matriz, todos ceros
ones = np.ones((2, 3))         # 2x3 matriz, todos unos
randn = np.random.randn(2, 3)  # números aleatorios de distribución normal

print(zeros.shape)  # (2, 3)

Este patrón es casi idéntico en PyTorch.

import torch

zeros_t = torch.zeros((2, 3))
ones_t = torch.ones((2, 3))
randn_t = torch.randn((2, 3))

5. dtype: entender el “tipo de dato” de los números

dtype significa data type, es decir, el tipo de los números dentro del array.

Tipos comunes:

  • int32, int64: enteros
  • float32, float64: flotantes (punto flotante)

Veamos un ejemplo:

x = np.array([1, 2, 3])
print(x.dtype)  # usualmente int64 o int32

y = np.array([1.0, 2.0, 3.0])
print(y.dtype)  # usualmente float64

5.1 Crear un array especificando dtype

x = np.array([1, 2, 3], dtype=np.float32)
print(x.dtype)  # float32

En deep learning se usa float32 (o torch.float32) porque es adecuado para GPU y ocupa memoria razonable.

6. shape: leer la “forma” de los datos

shape es una tupla que indica la forma (tamaño de cada dimensión) del array.

import numpy as np

x = np.array([1, 2, 3])
print(x.shape)  # (3,)

M = np.array([[1, 2, 3],
              [4, 5, 6]])
print(M.shape)  # (2, 3)

Ejemplos de shape que aparecen con frecuencia en deep learning:

  • Vector de características: (feature_dim,) → por ejemplo, (3,)
  • Batch de datos: (batch_size, feature_dim) → por ejemplo, (32, 3)
  • Batch de imágenes (PyTorch por defecto): (batch_size, channels, height, width) → por ejemplo, (32, 3, 224, 224)

Familiarizarte con estos shape en NumPy te ayuda a identificar errores de forma en PyTorch más rápidamente.

7. reshape: cambiar la forma

reshape cambia la forma del array sin alterar el número total de elementos.

import numpy as np

x = np.array([1, 2, 3, 4, 5, 6])
print(x.shape)  # (6,)

M = x.reshape(2, 3)
print(M)
print(M.shape)  # (2, 3)

Puntos clave:

  • El número total de elementos antes y después de reshape debe ser el mismo.

7.1 Usar -1 para cálculo automático

En procesamiento de batches o imágenes, -1 se usa con frecuencia. Significa “calcula automáticamente esta dimensión”.

x = np.array([[1, 2, 3],
              [4, 5, 6]])  # shape: (2, 3)

# Aplanar a 1D
flat = x.reshape(-1)        # shape: (6,)
print(flat)

# Volver a 2 filas, columnas calculadas automáticamente
M = flat.reshape(2, -1)     # shape: (2, 3)
print(M)

En PyTorch funciona de manera muy similar.

import torch

x_t = torch.tensor([[1, 2, 3],
                    [4, 5, 6]])  # (2, 3)

flat_t = x_t.reshape(-1)        # (6,)
M_t = flat_t.reshape(2, -1)     # (2, 3)

Con reshape bien dominado, puedes:

  • Flatten feature maps en CNN
  • Formatear entradas de RNN/LSTM a (batch, seq_len, feature)
  • Cambiar la posición de la dimensión batch

8. astype: cambiar el dtype

astype es la función que convierte el tipo de dato de un array.

import numpy as np

x = np.array([1, 2, 3])      # entero
print(x.dtype)               # int32 o int64

x_float = x.astype(np.float32)
print(x_float)
print(x_float.dtype)         # float32

Situaciones comunes en deep learning:

  • Convertir etiquetas enteras a flotantes para calcular la pérdida
  • Normalizar datos que llegan como float64 a float32
  • Asegurar tipos antes de pasar a PyTorch

Ejemplo:

import torch
import numpy as np

x = np.array([1, 2, 3], dtype=np.int32)
x = x.astype(np.float32)              # convertir a float32
x_torch = torch.from_numpy(x)         # convertir a tensor
print(x_torch.dtype)                  # torch.float32

Si no alineas los tipos, PyTorch puede lanzar errores como “Expected Float but got Double”.

9. Resumen: conceptos básicos de ndarray cubiertos hoy

En este artículo cubrimos:

  1. ¿Qué es ndarray? * La base de todas las estructuras de datos en deep learning
  2. Relación con Tensor de PyTorch * Conceptualmente idéntico, con diferencias de GPU y autograd
  3. np.array * Conversión de listas de Python a ndarray
  4. dtype * Tipos de datos numéricos (int, float, 32/64 bits)
  5. shape * Forma de los datos, crucial en deep learning
  6. reshape * Cambiar la forma sin alterar el número de elementos
  7. astype * Convertir tipos de datos

Dominar estos siete conceptos (array, dtype, shape, reshape, astype) te permitirá:

  • Evitar errores de forma sin sobresaltos
  • Navegar entre fórmulas de papers y código con fluidez
  • Seguir tutoriales de PyTorch de manera más cómoda

image