From e9ad8577d5c69db605d69f73e22e2ea89a57d4ca Mon Sep 17 00:00:00 2001 From: PEmurillo <69644770+PEmurillo@users.noreply.github.com> Date: Fri, 3 Dec 2021 11:52:46 -0600 Subject: [PATCH 1/2] Como crear vectores , matrices y tensores --- .../escalares_vectores_matrices.ipynb | 325 ++++++++++++++++++ 1 file changed, 325 insertions(+) create mode 100644 01 - Escalares - Vectores - Matrices - Tensores/escalares_vectores_matrices.ipynb diff --git a/01 - Escalares - Vectores - Matrices - Tensores/escalares_vectores_matrices.ipynb b/01 - Escalares - Vectores - Matrices - Tensores/escalares_vectores_matrices.ipynb new file mode 100644 index 0000000..1ce17cf --- /dev/null +++ b/01 - Escalares - Vectores - Matrices - Tensores/escalares_vectores_matrices.ipynb @@ -0,0 +1,325 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "68.45\n" + ] + } + ], + "source": [ + "escalar = 68.45\n", + "print(escalar)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True \n" + ] + } + ], + "source": [ + "#Creamos un escalar tipo booleano y lo mostramos\n", + "escalar_bool = True\n", + "print(escalar_bool, type(escalar_bool))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Importamos la libreria matematica necesaria para las operaciones\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2 3 4]\n" + ] + } + ], + "source": [ + "#Creamos un vector, el cual tiene un grado de libertad 1\n", + "vector = np.array([1,2,3,4])\n", + "print(vector)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 0]\n", + " [1 0 2]\n", + " [0 1 2]]\n" + ] + } + ], + "source": [ + "#Creamos una matriz,la cual tiene grado de libertad 2 \n", + "matriz = np.array([[1,2,0],[1,0,2],[0,1,2]])\n", + "print(matriz)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 1 2 3]\n", + " [ 4 5 6]\n", + " [ 7 8 9]]\n", + "\n", + " [[10 11 12]\n", + " [13 14 15]\n", + " [16 17 18]]\n", + "\n", + " [[19 20 21]\n", + " [22 23 24]\n", + " [25 26 27]]]\n" + ] + } + ], + "source": [ + "#Creamos un tensor \n", + "tensor = np.array([\n", + " [[1,2,3],[4,5,6],[7,8,9]],\n", + " [[10,11,12],[13,14,15],[16,17,18]],\n", + " [[19,20,21],[22,23,24],[25,26,27]]\n", + "])\n", + "print(tensor)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(tensor,interpolation=\"nearest\")\n", + "plt.show" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "tensor_2 = np.array([\n", + " [[0,0,0],[0,0,0],[0,0,0]],\n", + " [[128,128,128],[128,128,128],[128,128,128]],\n", + " [[255,255,255],[255,255,255],[255,255,255]]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAD8CAYAAABpXiE9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAANL0lEQVR4nO3dX8ie9X3H8fdnJh7EOq1NnDEm/oEwcIOuLqQ6x8igKxqE9KAbelBFBg9KHa3Ug1BBj3qwHRRmFWNYpQqdbmDVOFI6K2W6A0UNiRoz19TJfEhonLqoROayfXfwXHYPj/eT58nvvu4/se8X3NzXdf1+9/X7+lM+uf6aVBWSdLJ+Y9IFSDo1GR6SmhgekpoYHpKaGB6SmhgekpqsGObHSc4B/g64CHgD+LOqendAvzeA94H/AY5X1aZhxpU0ecMeeWwHnqqqjcBT3fpi/riqfs/gkD4dhg2PbcAD3fIDwFeG3J+kU0SGecI0yX9W1dnz1t+tqs8O6PdvwLtAAfdV1c4T7HMGmOlWf7+5OEnLUlVp+d2S4ZHkp8B5A5puBx5YZnicX1WHkpwLPAn8RVU9vWRxic/OSyPWGh5LXjCtqi8t1pbkl0nWVtXhJGuBI4vs41D3fSTJo8BmYMnwkDS9hr3msQu4oVu+AXh8YYckZyQ58+Nl4MvAK0OOK2nChr3m8Tng74ENwL8Df1pV7yQ5H/ibqtqa5BLg0e4nK4C/rarvLHP/nrZIIzayax6TZHhIo9caHj5hKqmJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqUkv4ZHkqiSvJTmYZPuA9iS5q2t/KcllfYwraXKGDo8kpwH3AFcDlwLXJbl0QbergY3dZwa4d9hxJU1WH0cem4GDVfV6VX0EPAxsW9BnG/BgzXkWODvJ2h7GljQhfYTHOuDNeeuz3baT7SPpFLKih31kwLZq6DPXMZlh7tRG0hTrIzxmgfXz1i8ADjX0AaCqdgI7AZIMDBhJk9fHacvzwMYkFyc5HbgW2LWgzy7g+u6uy+XA0ao63MPYkiZk6COPqjqe5BbgJ8BpwP1VtT/JTV37DmA3sBU4CBwDbhx2XEmTlarpPTPwtEUavaoadE1yST5hKqmJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIalJL+GR5KokryU5mGT7gPYtSY4m2dt97uhjXEmTs2LYHSQ5DbgH+BNgFng+ya6qenVB12eq6pphx5M0Hfo48tgMHKyq16vqI+BhYFsP+5U0xYY+8gDWAW/OW58Fvjig3xVJ9gGHgNuqav+gnSWZAWYAzjrrLG699dYeSpQ0yH333df82z6OPDJgWy1Y3wNcWFWfB74HPLbYzqpqZ1VtqqpNq1at6qE8SaPQR3jMAuvnrV/A3NHFr1TVe1X1Qbe8G1iZZHUPY0uakD7C43lgY5KLk5wOXAvsmt8hyXlJ0i1v7sZ9u4exJU3I0Nc8qup4kluAnwCnAfdX1f4kN3XtO4CvAjcnOQ58CFxbVQtPbSSdQvq4YPrxqcjuBdt2zFu+G7i7j7EkTQefMJXUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNSkl/BIcn+SI0leWaQ9Se5KcjDJS0ku62NcSZPT15HHD4CrTtB+NbCx+8wA9/Y0rqQJ6SU8qupp4J0TdNkGPFhzngXOTrK2j7ElTca4rnmsA96ctz7bbfuEJDNJXkjywrFjx8ZSnKSTN67wyIBtNahjVe2sqk1VtWnVqlUjLktSq3GFxyywft76BcChMY0taQTGFR67gOu7uy6XA0er6vCYxpY0Aiv62EmSh4AtwOoks8CdwEqAqtoB7Aa2AgeBY8CNfYwraXJ6CY+qum6J9gK+3sdYkqaDT5hKamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhqYnhIamJ4SGpieEhq0kt4JLk/yZEkryzSviXJ0SR7u88dfYwraXJ6+YuugR8AdwMPnqDPM1V1TU/jSZqwXo48qupp4J0+9iXp1NDXkcdyXJFkH3AIuK2q9g/qlGQGmAHYsGEDd9555xhLlH69PPHEE82/HdcF0z3AhVX1eeB7wGOLdayqnVW1qao2rVmzZkzlSTpZYwmPqnqvqj7olncDK5OsHsfYkkZjLOGR5Lwk6ZY3d+O+PY6xJY1GL9c8kjwEbAFWJ5kF7gRWAlTVDuCrwM1JjgMfAtdWVfUxtqTJ6CU8quq6JdrvZu5WrqRPCZ8wldTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1MTwkNTE8JDUxPCQ1GTo8EiyPsnPkhxIsj/JNwb0SZK7khxM8lKSy4YdV9Jk9fEXXR8HvlVVe5KcCbyY5MmqenVen6uBjd3ni8C93bekU9TQRx5Vdbiq9nTL7wMHgHULum0DHqw5zwJnJ1k77NiSJqfXax5JLgK+ADy3oGkd8Oa89Vk+GTCSTiG9hUeSzwCPAN+sqvcWNg/4SS2yn5kkLyR54a233uqrPEk96yU8kqxkLjh+WFU/GtBlFlg/b/0C4NCgfVXVzqraVFWb1qxZ00d5kkagj7stAb4PHKiq7y7SbRdwfXfX5XLgaFUdHnZsSZPTx92WK4GvAS8n2dtt+zawAaCqdgC7ga3AQeAYcGMP40qaoKHDo6r+mcHXNOb3KeDrw44laXr4hKmkJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJoaHpCaGh6QmhoekJkOHR5L1SX6W5ECS/Um+MaDPliRHk+ztPncMO66kyVrRwz6OA9+qqj1JzgReTPJkVb26oN8zVXVND+NJmgJDH3lU1eGq2tMtvw8cANYNu19J062PI49fSXIR8AXguQHNVyTZBxwCbquq/YvsYwaY6Vb/K8krfdY4pNXAf0y6iHmsZ2nTVtO01fPbrT9MVfVSQZLPAP8EfKeqfrSg7TeB/62qD5JsBf66qjYuY58vVNWmXgrsgfWc2LTVA9NX06epnl7utiRZCTwC/HBhcABU1XtV9UG3vBtYmWR1H2NLmow+7rYE+D5woKq+u0if87p+JNncjfv2sGNLmpw+rnlcCXwNeDnJ3m7bt4ENAFW1A/gqcHOS48CHwLW1vPOlnT3U1yfrObFpqwemr6ZPTT29XfOQ9OvFJ0wlNTE8JDWZmvBIck6SJ5P8vPv+7CL93kjycveY+wsjqOOqJK8lOZhk+4D2JLmra38pyWV919BQ09ge/09yf5Ijiz1/M6H5Waqmsb4escxXNsY2TyN7haSqpuID/BWwvVveDvzlIv3eAFaPqIbTgF8AlwCnA/uASxf02Qr8GAhwOfDciOdlOTVtAf5hTP+e/gi4DHhlkfaxzs8yaxrb/HTjrQUu65bPBP51kv8dLbOek56jqTnyALYBD3TLDwBfmUANm4GDVfV6VX0EPNzVNd824MGa8yxwdpK1E65pbKrqaeCdE3QZ9/wsp6axquW9sjG2eVpmPSdtmsLjt6rqMMz9wwLnLtKvgH9M8mL3KHuf1gFvzluf5ZOTvJw+464Jusf/k/w4ye+MsJ6ljHt+lmsi83OCVzYmMk/LeYVkuXPU67stS0nyU+C8AU23n8RurqyqQ0nOBZ5M8i/dnzx9yIBtC+9lL6dPn5Yz3h7gwvr/x/8fA5Z8/H9Exj0/yzGR+ele2XgE+GZVvbewecBPRjpPS9Rz0nM01iOPqvpSVf3ugM/jwC8/Pmzrvo8sso9D3fcR4FHmDuv7Mgusn7d+AXMv8p1snz4tOV5N1+P/456fJU1ifpZ6ZYMxz9MoXiGZptOWXcAN3fINwOMLOyQ5I3P/zxCSnAF8GejzrdvngY1JLk5yOnBtV9fCOq/vrpZfDhz9+HRrRJasacoe/x/3/Cxp3PPTjXXCVzYY4zwtp56mORrlVeeTvCL8OeAp4Ofd9znd9vOB3d3yJczdbdgH7AduH0EdW5m7Gv2Lj/cP3ATc1C0HuKdrfxnYNIa5WaqmW7r52Ac8C/zBCGt5CDgM/Ddzf3r++RTMz1I1jW1+uvH+kLlTkJeAvd1n66TmaZn1nPQc+Xi6pCbTdNoi6RRieEhqYnhIamJ4SGpieEhqYnhIamJ4SGryfyFU8LEZIu6HAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mostrar = plt.imshow(tensor_2,interpolation=\"nearest\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "tensor_2 = np.array([\n", + " [[0,10,20],[10,20,30],[20,30,40]],\n", + " [[128,138,148],[138,148,158],[148,158,168]],\n", + " [[255,255,255],[255,255,255],[255,255,255]]\n", + "])\n", + "plt.imshow(tensor_2,interpolation=\"nearest\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "tensor_2 = np.array([\n", + " [[0,100,20],[90,0,50],[20,90,40]],\n", + " [[128,138,148],[138,148,158],[148,158,168]],\n", + " [[255,255,255],[255,255,255],[255,255,255]]\n", + "])\n", + "plt.imshow(tensor_2,interpolation=\"nearest\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2]\n", + " [1 0]\n", + " [0 1]]\n" + ] + } + ], + "source": [ + "#Crear una matris 3x2\n", + "matriz_3x2 = np.array([[1,2],[1,0],[0,1]])\n", + "print(matriz_3x2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 4fd174ee8eba37ed59b35673a99c02f6f83679a9 Mon Sep 17 00:00:00 2001 From: PEmurillo <69644770+PEmurillo@users.noreply.github.com> Date: Fri, 3 Dec 2021 13:33:03 -0600 Subject: [PATCH 2/2] Funcion .shape y .size aplicada a vectores, matrices y tensores --- .../dimensiones .ipynb | 288 ++++++++++++++++++ 1 file changed, 288 insertions(+) create mode 100644 01 - Escalares - Vectores - Matrices - Tensores/dimensiones .ipynb diff --git a/01 - Escalares - Vectores - Matrices - Tensores/dimensiones .ipynb b/01 - Escalares - Vectores - Matrices - Tensores/dimensiones .ipynb new file mode 100644 index 0000000..1cb2019 --- /dev/null +++ b/01 - Escalares - Vectores - Matrices - Tensores/dimensiones .ipynb @@ -0,0 +1,288 @@ +{ + "cells": [ + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Producto interno\n", + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "escalar = 5.679\n", + "vector = np.array([1,2,3])\n", + "matriz = np.array([[1,2],[3,4]])\n", + "tensor = np.array([\n", + " [[1,2,3],[4,5,6],[7,8,9]],\n", + " [[10,11,12],[13,14,15],[16,17,18]],\n", + " [[19,20,21],[22,23,24],[25,26,27]]\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## .shape \n", + "Nos regresa la numero de diemensiones de lo que estemos evaluandp" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'float' object has no attribute 'shape'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mescalar\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m: 'float' object has no attribute 'shape'" + ] + } + ], + "source": [ + "#Como un escalar carece de una dimension al usar .shape nos da un error\n", + "escalar.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2 3]\n" + ] + }, + { + "data": { + "text/plain": [ + "(3,)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Nos devuelve que tenemso tres valores en solo 1 dimension \n", + "print(vector)\n", + "vector.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#la funcion len nos da menso informacion ya que si nos dice el numero de valores\n", + "#pero no aclara que solo hay una dimension \n", + "len(vector)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2]\n", + " [3 4]]\n" + ] + }, + { + "data": { + "text/plain": [ + "(2, 2)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(matriz)\n", + "matriz.shape " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(matriz)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 1 2 3]\n", + " [ 4 5 6]\n", + " [ 7 8 9]]\n", + "\n", + " [[10 11 12]\n", + " [13 14 15]\n", + " [16 17 18]]\n", + "\n", + " [[19 20 21]\n", + " [22 23 24]\n", + " [25 26 27]]]\n" + ] + }, + { + "data": { + "text/plain": [ + "(3, 3, 3)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(tensor)\n", + "tensor.shape " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## .size Nos muestra el numero de valores totales \n", + "Por ejemplo en una matriz 5x2 nos da como resultado 10 elemtos" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "27" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#nuestro tensor es de 3x3x3 \n", + "tensor.size" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#nuestra matriz es de 2x2\n", + "matriz.size" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}