ALG13-Tensores_COMPLETO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.1 - ¿Qué son los tensores?\n",
    "\n",
    "\n",
    "Un **tensor** es una generalización de vectores y matrices y se entiende fácilmente como una matriz multidimensional. A partir de esta definición podemos extrapolar que: \n",
    "\n",
    "- Un vector es un tensor unidimensional o de primer orden\n",
    "- Una matriz es un tensor bidimensional o de segundo orden.  \n",
    "\n",
    "<img src=\"Images/tensores.png\" width=40%/>\n",
    "\n",
    "La notación tensorial es muy parecida a la notación matricial con una letra mayúscula que representa un tensor y letras minúsculas con enteros subíndices que representan valores escalares dentro del tensor.  \n",
    "\n",
    "$\n",
    " T =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   t111, t121, t131 \\\\  \n",
    "   t211, t221, t231 \\\\  \n",
    "   t311, t321, t331 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   t112, t122, t132 \\\\  \n",
    "   t212, t222, t232 \\\\  \n",
    "   t312, t322, t332 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   t113, t123, t133 \\\\  \n",
    "   t213, t223, t233 \\\\  \n",
    "   t313, t323, t333 \\\\  \n",
    "  \\end{array} } \\right) \n",
    "$  \n",
    "\n",
    "Muchas de las operaciones que se pueden realizar con escalares, vectores y matrices se pueden reformular para que se realicen con tensores.  \n",
    "\n",
    "Como herramienta, los tensores y el álgebra tensorial se usan ampliamente en los campos de la física y la ingeniería. Al igual que los vectores y matrices, los tensores se pueden representar en Python usando la matriz N-dimensional (ndarray).  \n",
    "\n",
    "Un tensor se puede definir como una lista de listas.\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "    Un tensor de 3x3x3 en Python<br>\n",
    "    Primero definimos filas, luego una lista de filas apiladas como columnas, luego una lista de columnas apiladas como niveles en un cubo.\n",
    "</div> \n",
    "\n",
    "         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3, 3)\n",
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]\n",
      "  [ 7  8  9]]\n",
      "\n",
      " [[11 12 13]\n",
      "  [14 15 16]\n",
      "  [17 18 19]]\n",
      "\n",
      " [[21 22 23]\n",
      "  [24 25 26]\n",
      "  [27 28 29]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "T = np.array([[[1,2,3], [4,5,6], [7,8,9]], \n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]])\n",
    "\n",
    "print(T.shape)\n",
    "print(T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder a sus valores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [14, 15, 16],\n",
       "       [17, 18, 19]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[0][1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[0][1][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.2 - Suma de tensores\n",
    "\n",
    "La adición de dos tensores con las mismas dimensiones produce un nuevo tensor con las mismas dimensiones donde cada valor escalar es la adición de los escalares en los tensores padres.  \n",
    "\n",
    "\n",
    "$\n",
    "  A =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a111, a121, a131 \\\\  \n",
    "   a211, a221, a231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a112, a122, a132 \\\\  \n",
    "   a112, a122, a132 \\\\  \n",
    "  \\end{array} } \\right)\n",
    "$   \n",
    "\n",
    "$\n",
    "  B =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   b111, b121, t131 \\\\  \n",
    "   b211, t221, t231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   b112, b122, b132 \\\\  \n",
    "   b112, b122, b132 \\\\  \n",
    "  \\end{array} } \\right)\n",
    "$  \n",
    "\n",
    "$\n",
    "  A + B =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a111 + b111, a121 + b121, a131 + b131 \\\\  \n",
    "   a211 + b211, a221 + b221, a231 + b231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a112 + b112, a122 + b122, a132 + b132 \\\\  \n",
    "   a112 + b112, a122 + b122, a132 + b132 \\\\  \n",
    "  \\end{array} } \\right) , \n",
    "$   \n",
    "\n",
    "En `numpy`, podemos agregar tensores directamente agregando matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 2  4  6]\n",
      "  [ 8 10 12]\n",
      "  [14 16 18]]\n",
      "\n",
      " [[22 24 26]\n",
      "  [28 30 32]\n",
      "  [34 36 38]]\n",
      "\n",
      " [[42 44 46]\n",
      "  [48 50 52]\n",
      "  [54 56 58]]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]\n",
    "             ])\n",
    "\n",
    "B = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]])\n",
    "\n",
    "C = A + B\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0 0 0]\n",
      "  [0 0 0]\n",
      "  [0 0 0]]\n",
      "\n",
      " [[0 0 0]\n",
      "  [0 0 0]\n",
      "  [0 0 0]]\n",
      "\n",
      " [[0 0 0]\n",
      "  [0 0 0]\n",
      "  [0 0 0]]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]\n",
    "             ])\n",
    "\n",
    "B = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]])\n",
    "\n",
    "C = B - A\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.3 - Producto de tensores Hadamard\n",
    "\n",
    "La multiplicación por elementos de un tensor con otro tensor con las mismas dimensiones da como resultado un nuevo tensor con las mismas dimensiones donde cada valor escalar es la multiplicación por elementos de los escalares en los tensores padres.  \n",
    "\n",
    "La operación se conoce como Producto Hadamard para diferenciarla de la multiplicación tensorial. Aquí, utilizaremos el operador \"o\" para indicar el funcionamiento del producto Hadamard entre tensores.  \n",
    "\n",
    "$\n",
    "  A =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a111, a121, a131 \\\\  \n",
    "   a211, a221, a231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a112, a122, a132 \\\\  \n",
    "   a112, a122, a132 \\\\  \n",
    "  \\end{array} } \\right) \n",
    "$   \n",
    "\n",
    "$\n",
    "  B =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   b111, b121, t131 \\\\  \n",
    "   b211, t221, t231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   b112, b122, b132 \\\\  \n",
    "   b112, b122, b132 \\\\  \n",
    "  \\end{array} } \\right)\n",
    "$  \n",
    "\n",
    "$\n",
    "  A o B =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a111 * b111, a121 * b121, a131 * b131 \\\\  \n",
    "   a211 * b211, a221 * b221, a231 * b231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a112 * b112, a122 * b122, a132 * b132 \\\\  \n",
    "   a112 * b112, a122 * b122, a132 * b132 \\\\  \n",
    "  \\end{array} } \\right) , \n",
    "$  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.dot(A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  1,   4,   9],\n",
       "        [ 16,  25,  36],\n",
       "        [ 49,  64,  81]],\n",
       "\n",
       "       [[121, 144, 169],\n",
       "        [196, 225, 256],\n",
       "        [289, 324, 361]],\n",
       "\n",
       "       [[441, 484, 529],\n",
       "        [576, 625, 676],\n",
       "        [729, 784, 841]]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]\n",
    "             ])\n",
    "\n",
    "B = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]])\n",
    "\n",
    "C = A * B\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si cambiamos las dimensiones de uno de los tensores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A shape:  (3, 2, 3)\n",
      "B shape:  (3, 3, 3)\n",
      "C shape:  (3, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[[1,2,3],    [4,5,6]],\n",
    "              [[11,12,13], [14,15,16]],\n",
    "              [[21,22,23], [24,25,26]]\n",
    "             ])\n",
    "\n",
    "B = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]])\n",
    "\n",
    "print(\"A shape: \", A.shape)\n",
    "print(\"B shape: \", B.shape)\n",
    "print(\"C shape: \", C.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,2,3) (3,3,3) ",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-c229836d3ce8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mC\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mA\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mB\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mC\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,2,3) (3,3,3) "
     ]
    }
   ],
   "source": [
    "C = A * B\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.4 - División de tensores\n",
    "\n",
    "$\n",
    "  A =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a111, a121, a131 \\\\  \n",
    "   a211, a221, a231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a112, a122, a132 \\\\  \n",
    "   a112, a122, a132 \\\\  \n",
    "  \\end{array} } \\right) \n",
    "$   \n",
    "\n",
    "$\n",
    "  B =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   b111, b121, t131 \\\\  \n",
    "   b211, t221, t231 \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   b112, b122, b132 \\\\  \n",
    "   b112, b122, b132 \\\\  \n",
    "  \\end{array} } \\right) \n",
    "$  \n",
    "\n",
    "$\n",
    "  A / B =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   \\frac{a111}{b111}, \\frac{a121}{b121}, \\frac{a131}{b131} \\\\  \n",
    "   \\frac{a211}{b211}, \\frac{a221}{b221}, \\frac{a231}{b231} \\\\  \n",
    "  \\end{array} } \\right) ,\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   \\frac{a112}{b112}, \\frac{a122}{b122}, \\frac{a132}{b132} \\\\  \n",
    "   \\frac{a112}{b112}, \\frac{a122}{b122}, \\frac{a132}{b132} \\\\  \n",
    "  \\end{array} } \\right) , \n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1. 1. 1.]\n",
      "  [1. 1. 1.]\n",
      "  [1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1.]\n",
      "  [1. 1. 1.]\n",
      "  [1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1.]\n",
      "  [1. 1. 1.]\n",
      "  [1. 1. 1.]]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]\n",
    "             ])\n",
    "\n",
    "B = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]])\n",
    "\n",
    "C = A / B\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3, 3)\n",
      "(3, 3, 3)\n",
      "(3, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "print(A.shape)\n",
    "print(B.shape)\n",
    "print(C.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.5 - Producto tensor\n",
    "\n",
    "El operador del producto tensor a menudo se denota como un círculo con una pequeña x en el centro $\\otimes$.\n",
    "\n",
    "Dado un tensor $A$ con $q$ dimensiones y tensor $B$ con $r$ dimensiones, el producto de estos tensores será un nuevo tensor con $q + r$ dimensiones.\n",
    "\n",
    "El producto tensor no se limita a tensores, sino que también se puede realizar en matrices y vectores, que pueden ser un buen lugar para practicar con el fin de desarrollar la intuición para dimensiones superiores.\n",
    "\n",
    "### Producto tensor para vectores\n",
    "\n",
    "$a = (a1, a2)$<br>\n",
    "$b = (b1, b2)$<br>\n",
    "$c = a \\otimes b$<br>\n",
    "\n",
    "$\n",
    "  c =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a1 * [b1, b2] \\\\  \n",
    "   a2 * [b1, b2] \\\\  \n",
    "  \\end{array} } \\right) =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a1 * b1, a1 * b2 \\\\  \n",
    "   a2 * b1, a2 * b2 \\\\  \n",
    "  \\end{array} } \\right)  \n",
    "$   \n",
    "\n",
    "### Producto tensor para matrices\n",
    "\n",
    "$ A =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a11, a12 \\\\  \n",
    "   a21, a22 \\\\  \n",
    "  \\end{array} } \\right)\n",
    "$  \n",
    "\n",
    "$ B =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   b11, b12 \\\\  \n",
    "   b21, b22 \\\\  \n",
    "  \\end{array} } \\right)\n",
    "$  \n",
    "\n",
    "$C = A \\otimes B$<br>\n",
    " \n",
    "$ C =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a11*\\left( {\\begin{array}{cc}\n",
    "           b11, b12 \\\\  \n",
    "           b21, b22 \\\\  \n",
    "          \\end{array} } \\right), a12 *\\left( {\\begin{array}{cc}\n",
    "           b11, b12 \\\\  \n",
    "           b21, b22 \\\\  \n",
    "          \\end{array} } \\right) \\\\  \n",
    "   a21*\\left( {\\begin{array}{cc}\n",
    "           b11, b12 \\\\  \n",
    "           b21, b22 \\\\  \n",
    "          \\end{array} } \\right), a22 *\\left( {\\begin{array}{cc}\n",
    "           b11, b12 \\\\  \n",
    "           b21, b22 \\\\  \n",
    "          \\end{array} } \\right) \\\\ \n",
    "  \\end{array} } \\right) =\n",
    "  \\left( {\\begin{array}{cc}\n",
    "   a11 * b11, a11 * b12, a12 * b11, a12 * b12 \\\\  \n",
    "   a11 * b21, a11 * b22, a12 * b21, a12 * b22 \\\\ \n",
    "   a21 * b11, a21 * b12, a22 * b11, a22 * b12 \\\\ \n",
    "   a21 * b21, a21 * b22, a22 * b21, a22 * b22 \\\\ \n",
    "  \\end{array} } \\right) \n",
    "$   \n",
    "\n",
    "`Numpy` puede realizar el producto tensor usando la función `tensordot`. La función toma como argumentos **los dos tensores a multiplicar** y **el eje sobre el que se suman los productos**, llamada `sum reduction`. Para calcular el producto tensor, también llamado producto de punto tensor en `numpy`, el eje debe establecerse en 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 4]\n",
      " [6 8]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1, 2])\n",
    "B = np.array([3, 4])\n",
    "\n",
    "C = np.tensordot(A, B, axes=0)\n",
    "\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Igual a np.dot(A, B) pero para tensores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]\n",
    "             ])\n",
    "\n",
    "B = np.array([[[1,2,3],    [4,5,6],    [7,8,9]],\n",
    "              [[11,12,13], [14,15,16], [17,18,19]],\n",
    "              [[21,22,23], [24,25,26], [27,28,29]]])\n",
    "\n",
    "C = np.tensordot(A, B)\n",
    "C.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.6 - Tensores con TensorFlow\n",
    "\n",
    "Vamos a ver algunos pequeños ejemplos sobre tensores usando `tensorflow`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con `tf.constant()` generamos un escalar de tipo `int32`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(4, shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "rank_0_tensor = tf.constant(4)\n",
    "print(rank_0_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos crear un vector (1 axis):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([2. 3. 4.], shape=(3,), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "rank_1_tensor = tf.constant([2.0, 3.0, 4.0])\n",
    "print(rank_1_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([3])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_1_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tf.float32"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_1_tensor.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con 2 axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float16, numpy=\n",
       "array([[1., 2.],\n",
       "       [3., 4.],\n",
       "       [5., 6.]], dtype=float16)>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_2_tensor = tf.constant([[1, 2],\n",
    "                             [3, 4],\n",
    "                             [5, 6]], dtype=tf.float16)\n",
    "\n",
    "rank_2_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Images/tensors.png\" width=80%/>\n",
    "\n",
    "Con más axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2, 5), dtype=int32, numpy=\n",
       "array([[[ 0,  1,  2,  3,  4],\n",
       "        [ 5,  6,  7,  8,  9]],\n",
       "\n",
       "       [[10, 11, 12, 13, 14],\n",
       "        [15, 16, 17, 18, 19]],\n",
       "\n",
       "       [[20, 21, 22, 23, 24],\n",
       "        [25, 26, 27, 28, 29]]])>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_3_tensor = tf.constant([[[0, 1, 2, 3, 4],\n",
    "                             [5, 6, 7, 8, 9]],\n",
    "                            [[10, 11, 12, 13, 14],\n",
    "                             [15, 16, 17, 18, 19]],\n",
    "                            [[20, 21, 22, 23, 24],\n",
    "                             [25, 26, 27, 28, 29]]])\n",
    "rank_3_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay muchas formas de visualizar un tensor con 3 axis:\n",
    "\n",
    "<img src=\"Images/tensors_3axis.png\" width=80%/>\n",
    "\n",
    "Con `np.array()` podemos convertir un `tensor` a una variable de `numpy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2.],\n",
       "       [3., 4.],\n",
       "       [5., 6.]], dtype=float16)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(rank_2_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.array(rank_2_tensor))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(rank_2_tensor).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos realizar operaciones básicas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = tf.constant([[1, 2],\n",
    "                 [3, 4]])\n",
    "\n",
    "b = tf.constant([[1, 1],\n",
    "                 [1, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[2 3]\n",
      " [4 5]], shape=(2, 2), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# Suma\n",
    "print(tf.add(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[1 2]\n",
      " [3 4]], shape=(2, 2), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# Multiplicación - elemento a elemento a * b\n",
    "print(tf.multiply(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[3 3]\n",
      " [7 7]], shape=(2, 2), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# Multiplicación matricial np.dot(a, b)\n",
    "print(tf.matmul(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O usando los siguientes operadores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       "array([[2, 3],\n",
       "       [4, 5]])>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Suma\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       "array([[1, 2],\n",
       "       [3, 4]])>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplicación - elemento a elemento\n",
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       "array([[3, 3],\n",
       "       [7, 7]])>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplicación matricial\n",
    "a @ b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otro tipo de operaciones muy usadas son:\n",
    "\n",
    "- `tf.reduce_max()` para encontrar el valor más grande\n",
    "- `tf.argmax()` para encontrar el índice del valor más grande"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(10.0, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "c = tf.constant([[4.0, 5.0], [10.0, 1.0]])\n",
    "\n",
    "print(tf.reduce_max(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([1 0], shape=(2,), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "print(tf.argmax(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pytorch, TensorFlow (Keras) - frameworks Deep Learning\n",
    "# Pytorch - Facebook \n",
    "# TensorFlow - Google\n",
    "# Keras (TensorFlow)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}