Dimensiones, tensores y reshape

En una clase anterior para ejemplificar cómo se estructuran los tensores, el profesor dibujó una imagen tomando en cuenta el código de colores RGB.

Para practicar, hice un tensor que contenía un pixelart de la bandera de mi país 😄

Adjunto evidencia

El código:

G=[0,68,47]
R=[200,12,29]
W=[255,255,255]
B=[133,59,22]
LG=[101,108,38]
LB=[7,122,125]
O=[249,162,69]

tensorMexico=np.array([
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,B,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,B,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,LG,B,B,W,B,B,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,LG,B,B,B,B,B,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,LG,W,B,B,B,B,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,B,B,B,B,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,LG,R,W,B,B,R,LG,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,LG,W,G,R,G,W,LG,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,LG,LB,O,LB,LG,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,LG,LG,LG,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
    [G,G,G,G,G,G,G,G,G,W,W,W,W,W,W,W,W,W,R,R,R,R,R,R,R,R,R],
])

Para graficarlo:

%matplotlib inline

import matplotlib.pyplot as plt

plt.imshow(tensorMexico, interpolation='nearest')
plt.show()

Algo que mensionar es que:

x.reshape(2,4)

es diferente de

np.transpose(x) # o
x.T

Los datos pueden tener diferentes dimensiones dependiendo de su estructura y complejidad. A continuación se detallan las dimensiones más comunes:

1. Scalar: Un valor escalar representa una única cantidad o valor numérico sin ninguna dirección o magnitud asociada. Un ejemplo de valor escalar podría ser la temperatura actual en grados Celsius.

2. Vector: Un vector es una entidad matemática que tiene magnitud y dirección. Está compuesto por una secuencia de valores numéricos dispuestos en una sola dimensión. Un ejemplo común de vector es una lista de coordenadas que representan una posición en un espacio tridimensional.

3. Matrix: Una matriz es un conjunto de valores numéricos dispuestos en filas y columnas que forman una estructura bidimensional. Las matrices se utilizan para realizar cálculos lineales, como transformaciones lineales, rotaciones y escalamientos. Un ejemplo de matriz puede ser una imagen en escala de grises, que se puede representar como una matriz de píxeles.

4. Tensor: Un tensor es un objeto matemático de múltiples dimensiones que se utiliza en el análisis y procesamiento de datos en áreas como la física, la ingeniería y el aprendizaje automático. Un tensor puede ser un vector o una matriz de cualquier dimensión. Un ejemplo de tensor puede ser una imagen en color, que se puede representar como un tensor de tres dimensiones, con una dimensión para el ancho, otra para la altura y otra para los canales de color (rojo, verde y azul).

Mi resumen de clase 📝

En el contexto de \*\*redes neuronales\*\* y \*\*aprendizaje profundo (deep learning)\*\*, los conceptos de \*\*dimensiones\*\*, \*\*tensores\*\* y \*\*reshape\*\* son fundamentales, ya que describen cómo se organizan y manipulan los datos. \### 1. \*\*Tensores\*\* Un \*\*tensor\*\* es una estructura de datos multidimensional que generaliza los conceptos de escalares, vectores y matrices. En \*\*deep learning\*\*, los tensores son la base sobre la cual se alimentan los datos a los modelos. TensorFlow, PyTorch y otros marcos de aprendizaje profundo se basan en la manipulación de tensores. \#### Tipos de tensores según sus dimensiones: \- \*\*Escalar (0D tensor)\*\*: Un número simple, como \\( 5 \\) o \\( 3.14 \\). No tiene dimensiones. \- Ejemplo: `x = 5` \- \*\*Vector (1D tensor)\*\*: Una secuencia de números. Tiene una sola dimensión. \- Ejemplo: `x = \[1, 2, 3]` \- \*\*Matriz (2D tensor)\*\*: Una tabla de números con filas y columnas (similar a una hoja de cálculo). \- Ejemplo: \\\[ \text{matriz} = \begin{bmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \end{bmatrix} \\] \- \*\*Tensor 3D\*\*: Es una pila de matrices, o múltiples tablas de valores. Puede representar, por ejemplo, una colección de imágenes en color (cada imagen se representa con 3 matrices: rojo, verde, azul). \- Ejemplo: Un tensor 3D puede tener dimensiones de forma (64, 28, 28), lo que significa 64 imágenes de tamaño 28x28 píxeles. \- \*\*Tensor 4D y más\*\*: Se utilizan en casos más complejos, como imágenes a color en lotes (batch), donde cada imagen tiene 3 canales (RGB) y además está en un lote de imágenes. \- Ejemplo: Un tensor 4D con forma (128, 3, 64, 64) representa 128 imágenes en un lote, cada una con 3 canales de color y con dimensiones de 64x64 píxeles. \### 2. \*\*Dimensiones de un Tensor\*\* La \*\*dimensión\*\* de un tensor indica cuántos "ejes" o "direcciones" tiene. Por ejemplo: \- Un tensor 0D (escalar) no tiene ejes. \- Un tensor 1D (vector) tiene un solo eje (por ejemplo, la longitud del vector). \- Un tensor 2D (matriz) tiene dos ejes: filas y columnas. \- Un tensor 3D añade un tercer eje (profundidad, o número de matrices apiladas). \#### Ejemplos en código con `numpy`: ```python import numpy as np \# Escalar (0D) scalar = np.array(5) # Dimensión = 0 print(scalar.ndim) # Output: 0 \# Vector (1D) vector = np.array(\[1, 2, 3, 4]) # Dimensión = 1 print(vector.ndim) # Output: 1 \# Matriz (2D) matrix = np.array(\[\[1, 2], \[3, 4], \[5, 6]]) # Dimensión = 2 print(matrix.ndim) # Output: 2 \# Tensor 3D tensor\_3d = np.random.rand(64, 28, 28) # 64 imágenes de 28x28 píxeles print(tensor\_3d.ndim) # Output: 3 ``` \### 3. \*\*Reshape\*\* El método \*\*`reshape`\*\* se utiliza para cambiar la forma o estructura de un tensor sin modificar los datos que contiene. Esto es extremadamente útil cuando se trabaja con redes neuronales, ya que la entrada debe tener una forma específica para ser procesada correctamente por las capas del modelo. \#### Ejemplo: Supongamos que tienes imágenes en un conjunto de datos, donde cada imagen es de 28x28 píxeles en escala de grises (un tensor 2D por cada imagen). Para alimentar esas imágenes a una red neuronal, es necesario convertirlas en un tensor 1D (un vector) de longitud 784 (28x28). Esto se hace con `reshape`. ```python import numpy as np \# Imagen de 28x28 píxeles (tensor 2D) image = np.random.rand(28, 28) \# Reshape: convertir la imagen en un vector de 784 elementos image\_vector = image.reshape(28\*28) # O equivalente: image.reshape(-1) print(image\_vector.shape) # Output: (784,) ``` \### Reshape en Redes Neuronales En \*\*TensorFlow/Keras\*\*, al trabajar con imágenes, es común tener tensores de entrada con forma `(batch\_size, height, width, channels)`. A veces, necesitamos "aplanar" (flatten) estas imágenes para que se ajusten a una capa densa o completamente conectada. Ejemplo con Keras: ```python from tensorflow.keras.layers import Dense, Flatten from tensorflow.keras.models import Sequential \# Modelo secuencial con una capa de aplanamiento model = Sequential(\[ Flatten(input\_shape=(28, 28)), # Convierte el tensor 2D (28x28) en un vector 1D (784) Dense(128, activation='relu'), Dense(10, activation='softmax') # Salida para 10 clases ]) model.summary() ``` \### Ejemplo Práctico: MNIST con Reshape El dataset \*\*MNIST\*\* es un conjunto de imágenes de dígitos escritos a mano. Cada imagen tiene una resolución de 28x28 píxeles, lo que la convierte en un tensor 2D. Sin embargo, para las redes neuronales, generalmente se convierte en un tensor 1D (de 784 valores) antes de pasar a una capa completamente conectada. ```python from tensorflow.keras.datasets import mnist \# Cargar el conjunto de datos MNIST (x\_train, y\_train), (x\_test, y\_test) = mnist.load\_data() \# Reshape de las imágenes: de 28x28 a 784 x\_train = x\_train.reshape((60000, 28 \* 28)).astype('float32') / 255 x\_test = x\_test.reshape((10000, 28 \* 28)).astype('float32') / 255 \# Ver las dimensiones print(x\_train.shape) # Output: (60000, 784) print(x\_test.shape) # Output: (10000, 784) ``` \### Resumen \- \*\*Tensores\*\*: Son estructuras de datos que generalizan los conceptos de escalares, vectores y matrices. \- \*\*Dimensiones\*\*: Se refiere al número de "ejes" en un tensor (0D para escalares, 1D para vectores, 2D para matrices, etc.). \- \*\*Reshape\*\*: Cambia la forma de un tensor sin alterar los datos subyacentes, lo que es crucial para manipular correctamente los datos en redes neuronales. Con estos conceptos, puedes manipular y transformar los datos para ajustarlos a las necesidades de los modelos de aprendizaje profundo.

La diferencia que noto es que reshape te genera vectores tomando los datos secuencialmente y en cambio con transpose te genera los vectores agrupando por posición. x = np.array(\[\[0,1],             \[2,3],             \[4,5],             \[6,7],             \[8,9]]) ```js #DECLARACION ORIGINAL x = np.array([[0,1], [2,3], [4,5], [6,7], [8,9]]) # RESULTADO CON RESHAPE x.reshape(2,5) array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]) #RESULTADO CON TRANSPOSE np.transpose(x) array([[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]]) ```

Broadcasting

---

Además del reshape, es importante comprender el concepto de broadcasting. Broadcasting permite que las operaciones se realicen entre tensores de diferentes formas y tamaños, ajustando automáticamente las dimensiones para que las operaciones tengan sentido.

import tensorflow as tf


tensor_a = tf.constant([[1, 2, 3], [4, 5, 6]])


tensor_b = tf.constant([10, 20, 30])

resultado = tensor_a + tensor_b

print("Tensor A:")
print(tensor_a.numpy())

print("\nTensor B:")
print(tensor_b.numpy())

print("\nResultado después de Broadcasting:")
print(resultado.numpy())