No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Dimensiones, tensores y reshape

13/29
Recursos

¿Qué son los tipos de datos por dimensión?

Distinguir entre los tipos de datos por dimensión es crucial cuando trabajamos con frameworks avanzados como TensorFlow o PyTorch. Los datos se organizan en escalares, vectores, matrices y tensores, dependiendo de su complejidad y cantidad de información.

¿Cómo identificamos cada tipo de dato?

  1. Escalar: Un escalar contiene un único valor numérico y no tiene dimensiones, es decir, su dimensión es 0. Ejemplos incluyen valores como “5” o “A”.

  2. Vector: Es una lista o arreglo de valores en una sola dimensión. Tiene una dimensión de 1. Por ejemplo, un arreglo con valores como [5, 7, 9].

  3. Matriz: Contiene valores organizados en dos dimensiones, parecido a una hoja de cálculo de Excel con filas y columnas. Por ejemplo, una matriz puede presentar data points contra características.

  4. Tensor: Los tensores van más allá, manejan tres o más dimensiones. Son conjuntos de datos complejos que frameworks como TensorFlow entienden bien, aunque para los humanos resulten difíciles de visualizar más allá de tres dimensiones.

¿Cómo se aplican estos conceptos en ejemplos prácticos?

Ejemplos comunes para cada tipo de dato

  • Matrices: Suelen emplearse para representar data points contra características en un DataFrame.

  • Tensores: Los tensores tridimensionales se utilizan, por ejemplo, en series de tiempo, donde la tercera dimensión añade el elemento temporal. En el caso de imágenes, cuando están en color, se manejan cuatro dimensiones: número de ejemplos, alto, ancho y canales de color (rojo, verde y azul).

¿Cómo se implementa en Python?

La implementación práctica de estos conceptos se realiza con librerías como NumPy en Python. Aquí te mostramos cómo:

Crear y manipular escalares, vectores y matrices en NumPy

import numpy as np

# Escalar
escalar = np.array(42)

# Vector
vector = np.array([1, 2, 3, 4, 5])

# Matriz
matriz = np.array([[1, 2, 3], [4, 5, 6]])

print("Escalar dimensiones:", escalar.ndim)  # Output: 0
print("Vector dimensiones:", vector.ndim)    # Output: 1
print("Matriz dimensiones:", matriz.ndim)    # Output: 2

Creación y visualización de un tensor

# Tensor 3D
tensor = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print("Tensor dimensiones:", tensor.ndim)    # Output: 3

¿Qué es y cómo se utiliza reshape en NumPy?

reshape es una herramienta clave para cambiar la forma de un arreglo sin alterar sus datos. Por ejemplo, convertir una matriz de 4x2 en otra de 2x4:

# Reorganización con reshape
original = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6], [0.7, 0.8]])
nueva_forma = original.reshape((2, 4))

print("Forma original:", original.shape)
print("Nueva forma:", nueva_forma.shape)

¿Cómo modificar la dimensionalidad con transpose?

La transposición altera el orden de las dimensiones, útil en el procesamiento de datos. Así es como transpose puede emplearse en NumPy:

# Transposición de matriz
transpuesta = np.transpose(original)
print("Forma transpuesta:", transpuesta.shape)

Entender y manipular estas estructuras de datos es esencial para desarrollar redes neuronales efectivas. Las herramientas de NumPy permiten manejar dimensiones de manera eficiente, lo que es fundamental en el entrenamiento de modelos de machine learning. ¡Es el momento de experimentar y seguir ampliando tus conocimientos en redes neuronales aplicadas!

Aportes 15

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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()
  • Escalar: número simple. Tensor de orden 0.
  • Vector: es un arreglo ordenado de números. Tensor de orden 1.
  • Matriz: es un vector rectangular, dos dimensiones. Tensor de orden 2.
  • Tensor: es una identidad matemática que relaciona conjuntos de objetos en diferentes dimensiones.

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 📝

Recomiendo fuertemente el Curso de Fundamentos de Álgebra Lineal con Python para tener claro estos comandos

np.transpose(x) == x.T

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

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]]) ```

El tensor realmente significa que se puede transformar como un tensor (Un vector puede ser un tensor de orden 1). Esto significa que su transformación puede expresarse con el jacobiano, que es una matriz de derivadas.

hice el siguiente ejemplo```js print("matriz: ", x.reshape(2,2,2)) print("dimensiones: ", x.ndim) print("forma: ", x.shape) ##resultado #matriz: [[[0 1] [2 3]] [[4 5] [6 7]]] #dimensiones: 2 #forma: (4, 2) ```
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.

No entiendo porque escriben “Matrix” la pelicula, si se refieren al conjunto bidimensional de números se escribe “MATRIZ”.
Bueno… eso fue lo que yo aprendí en el colegio y la U, si estoy equivocado corríjanme (Con fundamentos por favor)

que bueno que tome el curso de numpy y panda dado por el mismo profe 😄