Matematicas-Estadistica/Cuadernos/t_0010_Intro_Tensores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#F72585\"><center>Introducción a tensores</center></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/puente_de_Brooklyn.jpg\" width=\"800\" height=\"400\" align=\"center\" /> \n",
    "</center>   \n",
    "</figure>\n",
    "<center>\n",
    "\n",
    "Fuente: <a href=\"https://commons.wikimedia.org/wiki/File:Vista_puente_de_Brooklyn.jpg\">Pixelillo</a>, <a href=\"https://creativecommons.org/licenses/by-sa/4.0\">CC BY-SA 4.0</a>, via Wikimedia Commons\n",
    "\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Introducción</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta lección se introducen los conceptos de vectores, matrices y tensores. Los tensores son la estructura de datos más utilizada en el aprendizaje profundo. Desde el punto de vista matemático, un tensor generaliza los conceptos de escalares, vectores y matrices. \n",
    "\n",
    "Solamente haremos la introducción al concepto de tensores desde el punto de vista de las estructuras de datos requeridas en el aprendizaje profundo.\n",
    "\n",
    "Los tensores constituyen el pilar fundamental de las estructuras de datos utilizadas en la inteligencia artificial (IA). Motores de aprendizaje profundo como Torch o TensorFlow se basan en Numpy, la librería por excelencia de Python para el manejo de tensores. Recientemente TensorFlow anunció el desarrollo propio de su librería de tensores en un intento de liberarse de Numpy.\n",
    "\n",
    "Desde el punto vista del aprendizaje de máquinas, los tensores con arreglos multidimensionales que generalizan las matrices a múltiples y a los cuales se les agregan algunas características adicionales como la diferenciación automática, que desarrollaremos en otra lección. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Dimensión y tamaño de un tensor</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los tensores pueden ser estructuras desde muy simples hasta muy complejos. Para poder describirlos, usamos los términos dimensión y tamaño. La siguiente imagen ilustra diferentes tipos de tensores. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La `dimensión de un tensor` se define como el número de índices requeridos para indicar la posición de un elemento en el tensor. En la imagen, es escalar es un tensor de dimensión cero, porque no se requiere ningún índice para determinar la posición de su único elemento. Cada índice requerido para indicar la posición de un elemento determina una dimensión del tensor. Así en ejemplo, de arriba el escalar tiene dimensión cero, el vector dimensión 1, la matriz es de  dimensión 2 y el último objeto a la derecha es un tensor de de dimensión 4. \n",
    "\n",
    "El `tamaño de un tensor` corresponde al número de elementos que se tienen al largo de cada dimensión. En la imagen el vector tiene tamaño 2 , indicado (2,) por acuerdo de notación. La matriz tiene tamaño (2,3) y el tensor de la derecha tiene tamaño (1,4,1,2).\n",
    "\n",
    "Para entender porque este último tensor tiene dimensión cuatro, observe lo siguiente. Hay un contenedor externo. Al representar el tensor en esta forma gráfica se da a entender que esta es la primera capa de varias posibles con la misma estructura. Al interior hay 4 compartimientos de tamaño (1,2), completando así el tamaño (1,4,1,2).\n",
    "()\n",
    "\n",
    "La siguiente ilustra una abstracción de juguete de un video con tres cuadros(frames) de color de forma (shape) $(2, 2)$ cada uno. Este seguro de entender la lógica de organización del tensor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/ten_tensor_4_d.jpg\" width=\"600\" height=\"400\" /> \n",
    "</center>\n",
    "</figure>\n",
    "\n",
    "Fuente: Alvaro Montenegro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La próxima imagen muestra la organización de diferentes tipos de tensores.\n",
    "\n",
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/ten_tensores.jpg\" width=\"600\" height=\"500\" align=\"center\"/>\n",
    "</center>\n",
    "<figcaption>\n",
    "<p style=\"text-align:center\">Ejemplos de tensores de diferentes  dimensiones y tamaños</p>\n",
    "</figcaption>\n",
    "</figure>\n",
    "\n",
    "Fuente: A. Montenegro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Nota acalaratoria</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El concepto de tensor en inteligencia artificial difiere del conocido en matemáticas y física. Un tensor desde el punto de vista matemático es a menudo, representado por una matriz de componentes que describen funciones relevantes para las coordenadas de un espacio. En pocas palabras, un tensor es una matriz de números que se transforman de acuerdo con ciertas reglas bajo un cambio de coordenadas. Un tensor se puede definir como un solo punto, una colección de puntos aislados, o se puede definir como un continuo de puntos en los que los elementos del tensor son funciones de posición, y el tensor forma lo que se conoce como campo tensor. Esto significa que en lugar de estar representado por un solo punto, el tensor se define en múltiples puntos juntos en un espacio.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/tensor_mat.png\" width=\"400\" height=\"400\" /> \n",
    "</center>\n",
    "</figure>\n",
    "\n",
    "\n",
    "Fuente: [Wikipedia](https://en.wikipedia.org/wiki/Tensor).\n",
    "\n",
    "El lector interesado en el concepto matemático , puede consultar en [Wikipedia](https://en.wikipedia.org/wiki/Tensor)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Adicionalmente la dimensión de un tensor es un concepto algebraico y no geométrico. En geometría cada componente en un vector representa una dimensión. Entonces el vector $(3,4)$ es un vector bidimensional desde el punto de vista geométrico. Gráficamente lo representamos en un plano como se muestra en la siguiente imagen. Desde el punto de vista tensorial, el mismo objeto es unidimensional, debido a que solamente se necesita un índice para identificar cada uno de sus elementos. Esta la definición que nos interesa aquí. El siguiente código dibuja algunos vectores en $\\mathbb{R}^2$. Los matemáticos dicen que estos objetos geométricos tienen dimensión geométrica 2. Por favor revisa cada línea del código para estar seguro de que lo entiende.\n",
    "\n",
    "Por favor revisa cada línea del siguiente código para estar asegurarse de que lo entiende. Cualquier duda consulte la documentación de Python. `ax.quiver`  crea el gráfico de los vectores, a partir de las coordenadas en $X, Y, U, V$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt \n",
    "soa = np.array([[0, 0, 4, 1], [0, 0, 1, 5], [0, 0, 3, 2]])\n",
    "X, Y, U, V = zip(*soa)\n",
    "\n",
    "plt.figure()\n",
    "plt.title('Vectores en el espacio Euclideano $R^2$ ')\n",
    "ax = plt.gca()\n",
    "ax.quiver(X, Y, U, V, angles='xy', scale_units='xy', scale=1, color='blue')\n",
    "ax.set_xlim([-1, 6])\n",
    "ax.set_ylim([-1, 6])\n",
    "plt.draw()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Escalares (Tensores de dimensión cero)</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un tensor de dimensión cero representa una cantidad escalar. Es decir, un tensor de dimensión cero solamente contendrá un número y por tanto tiene tamaño 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Vectores (Tensores unidimensionales)</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta sección revisamos el concepto de vector. Desde el punto de vista del aprendizaje profundo entendemos un vector como un contenedor de *n* datos, cada uno de los cuales se identifica genéricamente mediante un índice. Por ejemplo, supongamos que $w$ es un vector de tamaño tres. Este vector se representa genéricamente como:\n",
    "\n",
    "$$\n",
    "\\begin{equation*}\n",
    "w = (w_1,w_2, w_3).\n",
    "\\end{equation*}\n",
    "$$\n",
    "\n",
    "En estadística es usual escribir los vectores en columna. En este caso $w$ se escribe como:\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{equation*}\n",
    "w = \\begin{pmatrix} w_1\\\\ w_2 \\\\ w_3\\end{pmatrix}\n",
    "\\end{equation*}\n",
    "$$\n",
    "\n",
    "\n",
    "El tipo de valores que puede contener un vector debe ser de la misma clase por convención. Por ejemplo, si $w$ es un vector de números reales, entonces $z=(3.2\\;, 1.5 \\;, -7.2 \\;, 0.0)$ es un vector real de tamaño cuatro. Matemáticamente se dice que el vector $z$ tiene dimensión cuatro. En otras palabras, la dimensión matemática de un vector es su tamaño.\n",
    "\n",
    "El contenido y tipo de datos de un vector depende del contexto en que se está utilizando. Supongamos que se trata de construir una máquina de aprendizaje profundo que identifique dígitos escritos a mano en tonalidades de gris. Lo que se acostumbra a hacer es digitalizar las imágenes correspondientes, con lo cual se obtiene una matriz de números de tamaño digamos $255 \\times 255$. Esta matriz puede fácilmente transformarse a un vector, o mejor diríamos un tensor de dimensión 1, con $N = 255^2$ componentes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Ejemplo en NumPy</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En [NumPy](https://numpy.org/) el vector $w =(1,2,3)$ se puede crear así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# crea el vector (array)\n",
    "w = np.array([1,2,3]) \n",
    "# lo imprime\n",
    "print(w)\n",
    "# Muestra el tamaño (shape) del vector\n",
    "print(w.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Discusión: ¿Vector o Tensor?</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se dijo arriba, En geometría la dimensión hace referencia al número de componentes con el que se representa un objeto en un espacio. Por lo general usamos el espacio Euclidiano, digamos $\\mathbb{R}^2$ o $\\mathbb{R}^3$.\n",
    "\n",
    "Los tensores son objetos de tipo algebraico. La dimensión de un tensor se define como el número de índices requerido para representar todos a los elementos del tensor.\n",
    "\n",
    "Entonces:\n",
    "\n",
    "1. El vector $w = (w_1,w_2, w_3)$ tiene dimensión geométrica 3.\n",
    "2. El tensor $w = (w_1,w_2, w_3)$ tiene dimensión 1 y tamaño (*shape* = 3).\n",
    "\n",
    "**Asegúrese de comprender la diferencia**.\n",
    "\n",
    "El tipo de valores que puede contener un vector debe ser de la misma clase por convención. Por ejemplo, si $w$ es un vector de números reales, entonces $z=(3.2\\;, 1.5 \\;, -7.2 \\;, 0.0)$ es un vector real de tamaño cuatro. Matemáticamente se dice que el vector $z$ tiene dimensión cuatro. En otras palabras, la dimensión matemática de un vector es su tamaño."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Aritmética básica de tensores unidimensionales</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mientras no se diga lo contrario, asumiremos que los tensores que usaremos tienen el mismo tamaño. Por facilidad, en las definiciones usaremos tensores unidimensionales de tamaño $n=3$. En realidad el tamaño de los tensores unidimensionales pueden ser cualquier número entero positivo $n$ y las definiciones se generalizan de forma obvia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supongamos que $a= (a_1,a_2,a_3)$ y $b=(b_1,b_2,b_3)$ son dos vectores. La suma entre $a$ y $b$ es un vector $c$ definido por:\n",
    "\n",
    "$$\n",
    "c = a+b = (a_1+b_1, a_2+b_2,a_3+b_3)\n",
    "$$\n",
    "\n",
    "Por ejemplo, con Numpy escribimos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8 10 12]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([7,8,9])\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarmente la diferencia  de vectors $a-b$ es definida por:\n",
    "\n",
    "$$\n",
    "c = a-b = (a_1-b_1, a_2-b_2,a_3-b_3)\n",
    "$$\n",
    "\n",
    "Con Numpy operamos así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-6 -6 -6]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([7,8,9])\n",
    "c = a - b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El producto de Hadamard, o producto elemento por elemento entre dos vectores se denota $a \\odot b$ y se define como:\n",
    "\n",
    "$$\n",
    "c = a\\odot b = (a_1*b_1, a_2*b_2,a_3*b_3).\n",
    "$$\n",
    "\n",
    "En Python el producto de Hadamard se implementa simplemente usando el operador de multiplicación ( * ). Veamos:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7 16 27]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([7,8,9])\n",
    "c = a * b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La división entre vectores no es una operación formalmente definida. En ocasiones sin embargo se requiere dividir los elementos de un vector entre los elementos de otro, elemento a elemento. Esta operación se implementa en Python simplemente usando el operador división (/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.14285714 0.25       0.33333333]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([7,8,9])\n",
    "c = a / b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Matrices (Tensores bidimensionales)</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una matriz es una organización (tensor) bidimensional de objetos del mismo tipo. Por ejemplo una matriz  $M$ de tamaño $2\\times 3$ puede ser:\n",
    "\n",
    "$$\n",
    "\\begin{pmatrix} 1 & 2 & 3\\\\\n",
    "4 &5 & 6\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "Las matrices son muy utilizadas en prácticamente todas las áreas de la ciencia y la tecnología. \n",
    "\n",
    "En el caso del aprendizaje profundo, y más generalmente en Estadística las matrices se usan para representar conjuntos de datos. En los casos de regresión, las filas usualmente representan individuos y las columnas variables.\n",
    "\n",
    "En adelante llamaremos a las matrices tensores bidimensionales (o de dos dimensiones). Entonces una matriz que tiene $m$ filas y $n$ columnas, es un tensor bidimensional de tamaño (*shape*) $=(m,n)$.\n",
    "\n",
    "El tensor $M$ se representa en NumPy de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Crea el tensor\n",
    "M = np.array([[1,2,3],\n",
    "              [4,5,6]])\n",
    "# Imprime el Tensor\n",
    "print(M)\n",
    "# Muestra la forma (shape)\n",
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Creación de algunos tensores bidimensionales</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Tensor vacío</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función *empty()* crea un arreglo de la forma especificada. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.40222222 0.33722222 0.40222222]\n",
      " [4.03322222 5.36222222 0.33722222]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "v = np.empty([2,3])\n",
    "print(v)\n",
    "print(v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La salida puede parecer un poco extraña. En realidad lo que hace Numpy es reservar el espacio de memoria necesario para mantener un arreglo de tamaño $(2, 3)$, asignarle el nombre *v* en la tabla de objetos definidos dinámicamente y nada más. Entonces la información que se encontraba es ese lugar no se modifica. De hecho, si volvemos a correr en seguida la celda anterior de código, la salida no debe cambiar.\n",
    "\n",
    "\n",
    "Observe que *v* es un tensor que tiene forma (*shape*) $2\\times2$. En NumPy un tensor puede   estar compuesto por uno o más tensores. La dimensión del tensor *v* es 2. Se requiere un objeto de doble entrada para representar un tensor bidimensional. Dese cuenta de que al arreglo es mostrado como una lista con dos elementos, cada uno de los cuales es un arreglo de tamaño 3. Internamente, unos arreglos no se almacenan como una lista.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Tensor de ceros</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función *zeros()* crea un arreglo de la forma especificada relleno de ceros. Por ejemplo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "w = np.zeros([3,2])\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Arreglo de unos</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función *ones()* crea un arreglo de la forma especificada relleno de unos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]\n",
      " [1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "w = np.ones([2,2])\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\"> Apilamiento  de arreglos (stack)</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vertical: `vstack`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Con la función *vstack()*. Apila a lo largo del eje 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v = [[1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "w = [2 2 2]\n",
      "\n",
      "z = [[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [2. 2. 2.]]\n",
      "\n",
      "tamaño final = (3, 3)\n"
     ]
    }
   ],
   "source": [
    "v = np.ones([2,3])\n",
    "w = np.array([2,2,2])\n",
    "z = np.vstack((v,w))\n",
    "\n",
    "print('v = {}\\n'.format(v))\n",
    "print('w = {}\\n'.format(w))\n",
    "print('z = {}\\n'.format(z))\n",
    "\n",
    "print('tamaño final = {}'.format(z.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Horizontal: `hstack`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Con la función *hstack()*. Apila a lo largo del eje 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v = [[1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "w = [[5]\n",
      " [5]]\n",
      "\n",
      "z = [[1. 1. 1. 5.]\n",
      " [1. 1. 1. 5.]]\n",
      "\n",
      "tamaño final = (2, 4)\n"
     ]
    }
   ],
   "source": [
    "v = np.ones([2,3])\n",
    "w = np.array([[5],[5]])\n",
    "z = np.hstack((v,w))\n",
    "\n",
    "print('v = {}\\n'.format(v))\n",
    "print('w = {}\\n'.format(w))\n",
    "print('z = {}\\n'.format(z))\n",
    "\n",
    "print('tamaño final = {}'.format(z.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Apilamiento a lo largo de cualquier eje. `stack`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Con la función *stack()*. Apila a lo largo cualquier eje. La función *stack()* puede usarse para los dos casos anteriores cambiando el eje a lo largo del cual se hace la apilación. Revise el siguiente ejemplo en el cual apilamos una lista de arreglos a lo largo de cada uno de los ejes.\n",
    "\n",
    "Generamos una lista de 3 arreglos, cada uno de forma $(3, 4)$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Longitud de arrays = 3\n",
      "arrays[0] = \n",
      " [[ 0.13156864 -0.94740808  0.06717628 -1.50798456]\n",
      " [-0.63460968  0.31568777 -1.25686638 -0.41027075]\n",
      " [ 1.17615326  0.87941497 -0.75039359  0.07082663]]\n",
      "arrays[1] = \n",
      " [[ 1.9483979  -0.25963178  0.69517289  0.4072544 ]\n",
      " [ 1.68762712 -1.2348018   1.93836263  0.54969946]\n",
      " [-0.06352865 -0.18193205 -0.3013907  -1.47395905]]\n",
      "arrays[1] = \n",
      " [[-0.35192372 -0.6392832  -0.99033397  0.07240868]\n",
      " [ 0.70834801  0.59872016  0.85488812 -1.25189034]\n",
      " [-0.52253304  0.39805928  2.6775183   0.62660754]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arrays = [np.random.randn(3, 4) for _ in range(3)]\n",
    "print('Longitud de arrays =', len(arrays))\n",
    "print('arrays[0] = \\n', arrays[0])\n",
    "print('arrays[1] = \\n', arrays[1])\n",
    "print('arrays[1] = \\n', arrays[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0.13156864, -0.94740808,  0.06717628, -1.50798456],\n",
       "        [-0.63460968,  0.31568777, -1.25686638, -0.41027075],\n",
       "        [ 1.17615326,  0.87941497, -0.75039359,  0.07082663]],\n",
       "\n",
       "       [[ 1.9483979 , -0.25963178,  0.69517289,  0.4072544 ],\n",
       "        [ 1.68762712, -1.2348018 ,  1.93836263,  0.54969946],\n",
       "        [-0.06352865, -0.18193205, -0.3013907 , -1.47395905]],\n",
       "\n",
       "       [[-0.35192372, -0.6392832 , -0.99033397,  0.07240868],\n",
       "        [ 0.70834801,  0.59872016,  0.85488812, -1.25189034],\n",
       "        [-0.52253304,  0.39805928,  2.6775183 ,  0.62660754]]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.stack(arrays, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A lo largo del eje 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Creación de tensores multidimensionales</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python una lista de listas puede crearse como se muestra en el siguiente fragmento de código. En el código se observa como acceder a la primera lista y como acceder al segundo elemento de la segunda lista. Asegúrese de entender la lógica involucrada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a= [[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "a[0]= [1 2 3]\n",
      "\n",
      "a[1][1]= 5\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3],[4,5,6]])\n",
    "\n",
    "print('a=',a)\n",
    "print()\n",
    "print('a[0]=',a[0])\n",
    "print()\n",
    "\n",
    "print('a[1][1]=',a[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Un ejemplo con arreglos tridimensionales</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ayudar a entender la indexación y rebanado de arreglos, observe el siguiente ejemplo. Asegúrese de entender completamente la lógica. Vamos a crear un tensor tridimensional de tamaño $(4, 3, 1)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.shape= (4, 3, 2)\n",
      "\n",
      "a = [[[ 1  2]\n",
      "  [ 3  4]\n",
      "  [ 5  6]]\n",
      "\n",
      " [[ 7  8]\n",
      "  [ 9 10]\n",
      "  [11 12]]\n",
      "\n",
      " [[13 14]\n",
      "  [15 16]\n",
      "  [17 18]]\n",
      "\n",
      " [[19 20]\n",
      "  [21 22]\n",
      "  [23 24]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([\n",
    "              [[1,2],\n",
    "               [3,4],\n",
    "               [5,6]],\n",
    "             \n",
    "              [[7,8],\n",
    "               [9,10],\n",
    "               [11,12]],\n",
    "    \n",
    "              [[13,14],\n",
    "               [15,16],\n",
    "               [17,18]],\n",
    "    \n",
    "              [[19,20],\n",
    "               [21,22],\n",
    "               [23,24]]\n",
    "            ])\n",
    "\n",
    "print('a.shape=', a.shape)\n",
    "\n",
    "print('\\na =',a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Ejercicios</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Investigue sobre los siguientes temas:\n",
    "\n",
    "1. Indexación de tensores NumPy.\n",
    "2. Rebanado (slicing) tensores.\n",
    "3. Reorganización (Reshape) de tensores.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Ayuda</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Revise la lección de Numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Ejercicios adicionales</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Cree una lista 5 de arreglos aleatorios de forma $(2,4,3,5)$.\n",
    "1. Apile los arreglos por cada uno de los cuatro ejes.\n",
    "1. Interprete los resultados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. En las siguientes celdas, analice los arreglos y diga el shape de cada uno. A continuación tendrá la comprobación del shape. Adicional puede apilar los arreglos por cada uno de los correspondientes ejes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([\n",
    "              [\n",
    "                [[1, 2, 3, 4, 5],\n",
    "                 [6, 7, 8, 9, 10]],\n",
    "               \n",
    "                [[11, 12, 13, 14, 15],\n",
    "                 [16, 17, 18, 19, 20]]\n",
    "              ],\n",
    "              \n",
    "              [\n",
    "                [[21, 22, 23, 24, 25],\n",
    "                 [26, 27, 28, 29, 30]],\n",
    "               \n",
    "                [[31, 32, 33, 34, 35],\n",
    "                 [36, 37, 38, 39, 40]]\n",
    "              ],\n",
    "              \n",
    "              [\n",
    "                [[41, 42, 43, 44, 45],\n",
    "                 [46, 47, 48, 49, 50]],\n",
    "               \n",
    "                [[51, 52, 53, 54, 55],\n",
    "                 [56, 57, 58, 59, 60]]\n",
    "              ],\n",
    "              \n",
    "              [\n",
    "                [[61, 62, 63, 64, 65],\n",
    "                 [66, 67, 68, 69, 70]],\n",
    "               \n",
    "                [[71, 72, 73, 74, 75],\n",
    "                 [76, 77, 78, 79, 80]]\n",
    "              ]\n",
    "            ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('a.shape=', a.shape)\n",
    "\n",
    "print('\\na =',a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([\n",
    "              [[[1],\n",
    "                [2]],\n",
    "               [[3],\n",
    "                [4]],\n",
    "               [[5],\n",
    "                [6]],\n",
    "               [[7],\n",
    "                [8]]],\n",
    "             \n",
    "              [[[9],\n",
    "                [10]],\n",
    "               [[11],\n",
    "                [12]],\n",
    "               [[13],\n",
    "                [14]],\n",
    "               [[15],\n",
    "                [16]]],\n",
    "    \n",
    "              [[[17],\n",
    "                [18]],\n",
    "               [[19],\n",
    "                [20]],\n",
    "               [[21],\n",
    "                [22]],\n",
    "               [[23],\n",
    "                [24]]],\n",
    "    \n",
    "              [[[25],\n",
    "                [26]],\n",
    "               [[27],\n",
    "                [28]],\n",
    "               [[29],\n",
    "                [30]],\n",
    "               [[31],\n",
    "                [32]]],\n",
    "    \n",
    "              [[[33],\n",
    "                [34]],\n",
    "               [[35],\n",
    "                [36]],\n",
    "               [[37],\n",
    "                [38]],\n",
    "               [[39],\n",
    "                [40]]]\n",
    "            ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('a.shape=', a.shape)\n",
    "\n",
    "print('\\na =',a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([\n",
    "    [\n",
    "        [[1, 2, 3],\n",
    "         [4, 5, 6]],\n",
    "        \n",
    "        [[7, 8, 9],\n",
    "         [10, 11, 12]]\n",
    "    ],\n",
    "    \n",
    "    [\n",
    "        [[13, 14, 15],\n",
    "         [16, 17, 18]],\n",
    "        \n",
    "        [[19, 20, 21],\n",
    "         [22, 23, 24]]\n",
    "    ]\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('a.shape=', a.shape)\n",
    "\n",
    "print('\\na =',a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([\n",
    "    [\n",
    "        [\n",
    "            [[1, 2, 3], [4, 5, 6]],\n",
    "            [[7, 8, 9], [10, 11, 12]]\n",
    "        ],\n",
    "        [\n",
    "            [[13, 14, 15], [16, 17, 18]],\n",
    "            [[19, 20, 21], [22, 23, 24]]\n",
    "        ]\n",
    "    ],\n",
    "    [\n",
    "        [\n",
    "            [[25, 26, 27], [28, 29, 30]],\n",
    "            [[31, 32, 33], [34, 35, 36]]\n",
    "        ],\n",
    "        [\n",
    "            [[37, 38, 39], [40, 41, 42]],\n",
    "            [[43, 44, 45], [46, 47, 48]]\n",
    "        ]\n",
    "    ]\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('a.shape=', a.shape)\n",
    "\n",
    "print('\\na =',a)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('work')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  },
  "toc-autonumbering": false,
  "vscode": {
   "interpreter": {
    "hash": "3620b340ed2ed479d71e72c732c6d6a6eac39d8adbece51414abdea5ed84aec5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}