Matematicas-Estadistica/Cuadernos/t_0020_Algebra_Tensorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#F72585\"><center>Algebra tensorial</center></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/Duererquadrat_3_neu.jpg\" width=\"1000\" height=\"300\" align=\"center\" /> \n",
    "</center>   \n",
    "</figure>\n",
    "<center>\n",
    "\n",
    "Fuente: <a href=\"https://commons.wikimedia.org/wiki/File:Duererquadrat_3_neu.jpg\">Mabit1</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 revisamos en las operaciones tensoriales que se utilizan a diario en la inteligencia artificial. Póngale principal atención al producto tensorial general al final de la lección.\n",
    "\n",
    "El álgebra tensorial es tan importante en la inteligencia artificial que las tecnologías de hardware y las técnicas matemáticas para optimizar el cálculo tensorial son tema de desarrollo e investigación más recientes. La tecnología como GPU's, TPU's y otras más recientes se orientan casi exclusivamente al álgebra tensorial.\n",
    "\n",
    "Por ejemplo [Nvidia](https://www.nvidia.com/en-us/data-center/tensor-cores/)., el gigante tecnológico líder en GPU's ha desarrollado nuevas técnicas para el cálculo del álgebra tensorial, obviamente orientadas a sus GPU's que maximizan el rendimiento\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Algebra tensorial básica</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy está preparado para trabajar con las operaciones ordinarias del álgebra lineal y de manera más extendida con álgebra tensorial directamente. Los siguientes ejemplos muestran como sumar tensores. Usaremos tensores de tamaño $(3, 2, 3)$ en los ejemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tamaño de a = (3, 2, 3)\n",
      "\n",
      "a = [[[  1   2   3]\n",
      "  [  4   5   6]]\n",
      "\n",
      " [[ 10  20  30]\n",
      "  [ 40  50  60]]\n",
      "\n",
      " [[100 200 300]\n",
      "  [400 500 600]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# Operaciones con Tensores\n",
    "# Usamos 3*2*3 arrays (tensores)\n",
    "a = np.array([[[1,2,3],[4,5,6]],[[10,20,30],[40,50,60]],[[100,200,300],[400,500,600]]])\n",
    "\n",
    "print('tamaño de a = {}\\n'.format(a.shape))\n",
    "print('a =',a)\n",
    "# Observe que se tiene 3 capas con shape 2*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Multiplicación por una constante: -1*Tensor</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tamaño de b = (3, 2, 3)\n",
      "\n",
      "b = [[[  -1   -2   -3]\n",
      "  [  -4   -5   -6]]\n",
      "\n",
      " [[ -10  -20  -30]\n",
      "  [ -40  -50  -60]]\n",
      "\n",
      " [[-100 -200 -300]\n",
      "  [-400 -500 -600]]]\n"
     ]
    }
   ],
   "source": [
    "# multiplicar por -1\n",
    "b = -a\n",
    "print('tamaño de b = {}\\n'.format(b.shape))\n",
    "print('b =', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Suma de tensores</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se asume que los tensores que se suman tienen exactamente la misma forma (shape). Puede haber tantos sumandos como se quiera. La suma ocurre componente a componente, es decir se suman las componentes que están en la misma posición en cada uno de los tensores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tamaño de c = (3, 2, 3)\n",
      "\n",
      "c = [[[0 0 0]\n",
      "  [0 0 0]]\n",
      "\n",
      " [[0 0 0]\n",
      "  [0 0 0]]\n",
      "\n",
      " [[0 0 0]\n",
      "  [0 0 0]]]\n"
     ]
    }
   ],
   "source": [
    "# suma\n",
    "c = a + b\n",
    "\n",
    "print('tamaño de c = {}\\n'.format(c.shape))\n",
    "print('c =', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Resta de dos tensores</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se asume que los tensores que se restan tienen exactamente la misma forma (shape).  La resta ocurre componente a componente, es decir se restan las componentes que están en la misma posición en cada uno de los dos tensores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tamaño de c = (3, 2, 3)\n",
      "\n",
      "c = [[[   2    4    6]\n",
      "  [   8   10   12]]\n",
      "\n",
      " [[  20   40   60]\n",
      "  [  80  100  120]]\n",
      "\n",
      " [[ 200  400  600]\n",
      "  [ 800 1000 1200]]]\n"
     ]
    }
   ],
   "source": [
    "# diferencia entre dos tensores\n",
    "c = a - b\n",
    "\n",
    "print('tamaño de c = {}\\n'.format(c.shape))\n",
    "print('c =', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Producto de Hadamard</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se asume que los tensores que se multiplican tienen exactamente la misma forma (shape).  La multiplicación ocurre componente a componente, es decir se multiplican las componentes que están en la misma posición en cada uno de los dos tensores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [[[  1   2   3]\n",
      "  [  4   5   6]]\n",
      "\n",
      " [[ 10  20  30]\n",
      "  [ 40  50  60]]\n",
      "\n",
      " [[100 200 300]\n",
      "  [400 500 600]]]\n",
      "\n",
      "b = [[[  -1   -2   -3]\n",
      "  [  -4   -5   -6]]\n",
      "\n",
      " [[ -10  -20  -30]\n",
      "  [ -40  -50  -60]]\n",
      "\n",
      " [[-100 -200 -300]\n",
      "  [-400 -500 -600]]]\n",
      "\n",
      "tamaño de c = (3, 2, 3)\n",
      "\n",
      "a * b = [[[     -1      -4      -9]\n",
      "  [    -16     -25     -36]]\n",
      "\n",
      " [[   -100    -400    -900]\n",
      "  [  -1600   -2500   -3600]]\n",
      "\n",
      " [[ -10000  -40000  -90000]\n",
      "  [-160000 -250000 -360000]]]\n"
     ]
    }
   ],
   "source": [
    "# producto de Hadamard\n",
    "c = a * b\n",
    "\n",
    "print('a =', a)\n",
    "print()\n",
    "\n",
    "print('b =', b)\n",
    "print()\n",
    "\n",
    "print('tamaño de c = {}\\n'.format(c.shape))\n",
    "print('a * b =', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">División entre vectores: componente a componente</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se asume que los tensores que se dividen componente a componente tienen exactamente la misma forma (shape).  La división ocurre componente a componente, es decir se dividen entre sí las componentes que están en la misma posición en cada uno de los dos tensores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c= [[[-1. -1. -1.]\n",
      "  [-1. -1. -1.]]\n",
      "\n",
      " [[-1. -1. -1.]\n",
      "  [-1. -1. -1.]]\n",
      "\n",
      " [[-1. -1. -1.]\n",
      "  [-1. -1. -1.]]]\n",
      "(3, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# división componente a componente\n",
    "c = a / b\n",
    "print(\"c=\",c)\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Producto escalar (dot product)</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si $a=(a_1,a_2,a_3)$ y $b=(b_1,b_2, b_3)$, el  el producto escalar entre $a$ y $b$ está definido por:\n",
    "\n",
    "$$\n",
    "<a,b> = a_1b_1 + a_2b_2+a_3b_3\n",
    "$$\n",
    "\n",
    "Este producto es base de mucho métodos estadísticos, como la comparación misma de vectores.\n",
    "\n",
    "Con NumPy escribimos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c = <a, b> = 32\n",
      "tamaño de c = ()\n"
     ]
    }
   ],
   "source": [
    "# dot product (vectores): c = sum(a_i*b_i)\n",
    "a = np.array([1,2,3])\n",
    "b = np.array([4,5,6])\n",
    "\n",
    "c = np.dot(a,b)\n",
    "\n",
    "print(\"c = <a, b> =\",c)\n",
    "print(\"tamaño de c =\",c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Producto de matrices (2D-Tensores)</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supongamos que $A=[a_{ij}]_{N\\times P}$ y  $B=[b_{jk}]_{P\\times Q}$ son matrices de tamaños (*shape*) $N\\times P$ y $P\\times Q$ respectivamente. Entonces $C = A\\times B$ es una matriz $C=[c_{ik}]_{N\\times Q}$ de tamaño $P\\times Q$, en donde:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "c_{ik} = \\sum_{j=1}^{P} a_{ij}b_{jk}\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "Observe detenidamente el cálculo mostrado en la siguiente imagen, el cual ilustra el producto entre dos matrices, cada una de forma $(2, 2)$ ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/producto_matriz.png\" width=\"600\" height=\"200\" /> \n",
    "</center>\n",
    "</figure>\n",
    "\n",
    "Fuente: [studypug](https://www.studypug.com/algebra-help/properties-of-matrix-to-matrix-multiplication)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Numpy existen varias manera de calcular el producto entre dos matrices. Si $A$ y $B$ son dos matrices, entonces el producto matricial se denota en una de las siguiente formas\n",
    "\n",
    "* C = A @ B\n",
    "* C = np.matmul(A,B)\n",
    "* C = np.dot(A,B)\n",
    "\n",
    "La última expresión es bastante sugerente. Indica que el producto punto se define entre matrices, y el caso que estudiamos previamente es el caso particular en donde los tensores tiene forma $(1, n)$ y $(n, 1)$ respectivamente.\n",
    "\n",
    "Más adelante vamos a constatar que el producto entre matrices es un caso particular del producto tensorial general."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = [[1 2 3]\n",
      " [4 5 6]]\n",
      "A.shape = (2, 3)\n",
      "\n",
      "B = [[ 10  20  30  40]\n",
      " [ 50  60  70  80]\n",
      " [ 90 100 110 120]]\n",
      "B.shape = (3, 4)\n",
      "\n",
      "C= [[ 380  440  500  560]\n",
      " [ 830  980 1130 1280]]\n",
      "C.shape = (2, 4)\n",
      "D= [[ 380  440  500  560]\n",
      " [ 830  980 1130 1280]]\n",
      "E= [[ 380  440  500  560]\n",
      " [ 830  980 1130 1280]]\n"
     ]
    }
   ],
   "source": [
    "# producto de matrices (tensores ): c = sum(a_i*b_i)\n",
    "A = np.array([[1,2,3],[4,5,6]])\n",
    "B = np.array([[10,20,30,40],[50,60,70,80],[90,100,110,120]])          \n",
    "print(\"A =\",A)\n",
    "print(\"A.shape =\",A.shape)\n",
    "print()\n",
    "\n",
    "print(\"B =\",B)\n",
    "print(\"B.shape =\",B.shape)\n",
    "print()\n",
    "\n",
    "# producto de matrices ( resultado equivalente)\n",
    "# se prefiere el cálculo de C o D\n",
    "C = A @ B\n",
    "\n",
    "D = np.matmul(A,B)\n",
    "\n",
    "E = np.dot(A,B)\n",
    "\n",
    "print(\"C=\",C)\n",
    "print(\"C.shape =\",C.shape)\n",
    "print(\"D=\",D)\n",
    "print(\"E=\",E)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">El producto matricial puede ser concatenado en Numpy</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pueden escribirse varias expresiones de producto punto seguidas. Si no hay paréntesis en al expresión, el cálculo ocurre de izquierda a derecha. Veamos el siguiente ejemplo. Ejecútelo usted mismo y obtenga sus propias conclusiones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =\n",
      " [[1. 0.]\n",
      " [0. 1.]]\n",
      "\n",
      "b =\n",
      "  [[2. 2.]\n",
      " [2. 2.]]\n",
      "\n",
      "a.dot(b)\n",
      " = [[2. 2.]\n",
      " [2. 2.]]\n",
      "\n",
      "a.dot(b).dot(b) =\n",
      " [[8. 8.]\n",
      " [8. 8.]]\n"
     ]
    }
   ],
   "source": [
    "# a.dot puede ser encadenado con arreglos 2D\n",
    "a = np.eye(2) #matriz identidad  2x2\n",
    "print('a =\\n', a)\n",
    "print()\n",
    "\n",
    "b = np.ones((2,2))*2 # matriz 2x2, lleno con números 2 .\n",
    "print ('b =\\n ', b)\n",
    "print()\n",
    "\n",
    "print('a.dot(b)\\n =',  a.dot(b))\n",
    "print()\n",
    "\n",
    "print('a.dot(b).dot(b) =\\n', a.dot(b).dot(b) )\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Resumen de producto entre tensores simples</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La imagen resume la manera como se realizan los distintos tipo de producto tensorial revisado  hasta este momento. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/dot_product.png\" width=\"800\" height=\"400\" /> \n",
    "</center>\n",
    "</figure>\n",
    "\n",
    "Fuente [wordpress](https://algebra1course.files.wordpress.com/2013/02/slide10.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Producto tensorial general</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Matematicas/Imagenes/producto_tensorial.png\" width=\"800\" height=\"600\" /> \n",
    "</center>\n",
    "</figure>\n",
    "\n",
    "Fuente: Alvaro Montenegro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La imagen ilustra la operación tensorial más usual en inteligencia artificial. El tensor de la izquierda (*azul*) tiene forma $(3,3,3)$. Puede imaginar que este tensor representa una imagen a color de tamaño $3\\times 3$. El tensor en el centro tiene forma $(3, 2)$ (*rosa*), el cual puede usted pensar como un filtro (más preciso sería decir un kernel) qu va a operar sobre cada una de las capas de color de la imagen. ¿Y cómo lo hace?\n",
    "\n",
    "Pues sencillamente efectúa el producto de la matriz de cada color, es decir cada capa de la matriz *azul* con el filtro, es decir con la matriz *rosa*. \n",
    "\n",
    " Entonces el producto se efectúa de la siguiente manera:\n",
    " \n",
    " * La primera capa de la matriz *azul* tiene forma $(3,3)$ se multiplica matricialmente con la matriz *rosa*, dando como resultado la matriz de la primera capa del tensor destino (*turquesa*), de forma $(3, 2)$.\n",
    " \n",
    " * La segunda capa de la matriz *azul* tiene forma $(3,3)$ se multiplica matricialmente con la matriz *rosa*, dando como resultado la matriz de la segunda capa del tensor destino (*turquesa*), de forma $(3, 2)$.\n",
    "  \n",
    "* La tercera capa de la matriz *azul* tiene forma $(3,3)$ se multiplica matricialmente con la matriz *rosa*, dando como resultado la matriz de la tercera capa del tensor destino (*verde), de forma $(3, 2)$.\n",
    "\n",
    "Al final el tensor verde tiene forma $(3, 3, 2)$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De manera un poco más general, vamos a suponer que cada elemento en los tensores de dimensión 3 se indexan mediante coordenadas (fila, columna, profundidad) y que los tensores de dimensión 2 se indexan como (fila, columna).\n",
    "\n",
    "La siguiente imagen ilustra la forma de un producto tensorial. \n",
    "\n",
    "- A la izquierda (azul) se tiene un tensor de tamaño digamos $n \\times p \\times s$. \n",
    "\n",
    "- El tensor que está operando en el centro (rosa) es  de tamaño $p \\times r$. Este actúa operando en este caso sobre cada capa del tensor de la izquierda haciendo un producto usual de matrices. \n",
    "\n",
    "- Por lo que el tensor resultante (verde) a la derecha tiene tamaño $n \\times r \\times s$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Explicación del producto con un ejemplo parcial</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La explicación del proceso es la siguiente:\n",
    "\n",
    "Cada capa frontal del tensor azul es multiplica por el tensor rosa y el resultado es colocando como una capa frontal en el tensor resultante (verde).\n",
    "\n",
    "Cada multiplicación es entre dos matrices (azul * rosa) y el resultado es una matriz (verde).\n",
    "\n",
    "Cada multiplicación de matrices se hace por la fórmula fila (matriz azul) * columna (matriz rosa)\n",
    "\n",
    "Supongamos por ejemplo que una capa es $ azul  = \\begin{pmatrix} 1 & 2 & 1\\\\ 3 & 4 & 1 \\\\ 4 & 5  & 0\\\\ \\end{pmatrix}$, $rosa = \\begin{pmatrix} 5 & 10\\\\ 20 & 30 \\\\ 4 & 1\\end{pmatrix}$\n",
    "\n",
    "Entonces se tiene que \n",
    "\n",
    "$$\n",
    "azul \\times rosa = \\begin{pmatrix} 1 & 2 & 1\\\\ 3 & 4 & 1 \\\\ 4 & 5 & 0\\\\ \\end{pmatrix} \\times \\begin{pmatrix} 5 & 10\\\\ 20 & 30\\\\ 4 & 1\\end{pmatrix} = \\begin{pmatrix} 1\\times 5 + 2 \\times 20 +  1 \\times 4 & 1 \\times 10 + 2\\times 30 + 1\\times 1\n",
    "\\\\ 3\\times 5 + 4 \\times 20 + 1 \\times 4 & 3 \\times 10 + 4 \\times 30 + 1 \\times 1\n",
    "\\\\ 4\\times 5 + 5 \\times 20 + 0 \\times 4 & 4 \\times 10 + 5 \\times 30 + 0 \\times 1\\end{pmatrix} = turquesa\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para terminar la lección, revisemos el siguiente ejemplo numérico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.array([[[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",
    "b = np.array([[10],[100]])\n",
    "c = a.dot(b)   \n",
    "d = a@b\n",
    "# revisamos este subcálculo. a_0 es la primera matriz 3x2 del arreglo A.\n",
    "a_0 = a[0,:,:]\n",
    "# e es la primera matriz de tamaño 3*1 del producto. Compare los resultados.\n",
    "e = a_0@b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.shape = (4, 3, 2)\n",
      "a =\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",
      "b.shape = (2, 1)\n",
      " b=\n",
      " [[ 10]\n",
      " [100]]\n",
      "\n",
      "c.shape = (4, 3, 1)\n",
      "c =\n",
      " [[[ 210]\n",
      "  [ 430]\n",
      "  [ 650]]\n",
      "\n",
      " [[ 870]\n",
      "  [1090]\n",
      "  [1310]]\n",
      "\n",
      " [[1530]\n",
      "  [1750]\n",
      "  [1970]]\n",
      "\n",
      " [[2190]\n",
      "  [2410]\n",
      "  [2630]]]\n",
      "\n",
      "d.shape = (4, 3, 1)\n",
      "d =\n",
      " [[[ 210]\n",
      "  [ 430]\n",
      "  [ 650]]\n",
      "\n",
      " [[ 870]\n",
      "  [1090]\n",
      "  [1310]]\n",
      "\n",
      " [[1530]\n",
      "  [1750]\n",
      "  [1970]]\n",
      "\n",
      " [[2190]\n",
      "  [2410]\n",
      "  [2630]]]\n",
      "\n",
      "e.shape =\n",
      " (3, 1)\n",
      "e= [[210]\n",
      " [430]\n",
      " [650]]\n",
      "\n",
      "a_0.shape (3, 2)\n",
      "a_0 =\n",
      " [[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "print('a.shape =',a.shape)\n",
    "print('a =\\n', a)\n",
    "print()\n",
    "\n",
    "print('b.shape =',b.shape)\n",
    "print(' b=\\n', b)\n",
    "print()\n",
    "\n",
    "print('c.shape =',c.shape)\n",
    "print('c =\\n', c)\n",
    "print()\n",
    "\n",
    "print('d.shape =',d.shape)\n",
    "print('d =\\n', d)\n",
    "print()\n",
    "\n",
    "print('e.shape =\\n',e.shape)\n",
    "print('e=', e)\n",
    "print()\n",
    "\n",
    "print('a_0.shape',a_0.shape)\n",
    "print('a_0 =\\n', a_0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#4361EE\">Ejercicios</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con estos ejercicios hacemos una generalización adicional del producto tensorial. \n",
    "\n",
    "1. Cree con Numpy un tensor *a* aleatorio de forma $(3, 4, 5)$.\n",
    "1. Cree con Numpy un tensor *b* aleatorio de forma $(5, 2)$.\n",
    "1. Calcule el producto  $c = a.dot(b)$\n",
    "1. Escriba el resultado. \n",
    "1. Calcule la forma del tensor *c*.\n",
    "1. Explique como se ha hecho el producto.\n",
    "1. Cambie la forma de los tensores arbitrariamente y reintente el cálculo.\n",
    "1. Explique lo ocurrido.\n",
    "\n",
    "1. Cree con Numpy un tensor *a* aleatorio de forma $(3, 4, 5)$.\n",
    "1. Cree con Numpy un tensor *b* aleatorio de forma $(2, 5, 3)$.\n",
    "1. Calcule el producto  $c = a.dot(b)$\n",
    "1. Escriba el resultado. \n",
    "1. Calcule la forma del tensor *c*.\n",
    "1. Explique como se ha hecho el producto.\n",
    "1. Cambie la forma de los tensores arbitrariamente y reintente el cálculo.\n",
    "1. Explique lo ocurrido."
   ]
  }
 ],
 "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.9.13"
  },
  "toc-autonumbering": false,
  "vscode": {
   "interpreter": {
    "hash": "3620b340ed2ed479d71e72c732c6d6a6eac39d8adbece51414abdea5ed84aec5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}