{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 张量 Tensor\n",
    "\n",
    "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.8/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.8/tutorials/zh_cn/beginner/mindspore_tensor.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.8/resource/_static/logo_download_code.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.8/tutorials/zh_cn/beginner/mindspore_tensor.py)\n",
    " [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.8/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r1.8/tutorials/source_zh_cn/beginner/tensor.ipynb)\n",
    "\n",
    "张量（Tensor）是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数，这些线性关系的基本例子有内积、外积、线性映射以及笛卡儿积。其坐标在 $n$ 维空间内，有  $n^{r}$ 个分量的一种量，其中每个分量都是坐标的函数，而在坐标变换时，这些分量也依照某些规则作线性变换。$r$ 称为该张量的秩或阶（与矩阵的秩和阶均无关系）。\n",
    "\n",
    "张量是一种特殊的数据结构，与数组和矩阵非常相似。张量（[Tensor](https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore/mindspore.Tensor.html)）是MindSpore网络运算中的基本数据结构，本章主要介绍张量和稀疏张量的属性及用法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建张量\n",
    "\n",
    "张量的创建方式有多种，构造张量时，支持传入`Tensor`、`float`、`int`、`bool`、`tuple`、`list`和`numpy.ndarray`类型。\n",
    "\n",
    "- **根据数据直接生成**\n",
    "\n",
    "可以根据数据创建张量，数据类型可以设置或者通过框架自动推断。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore as ms\n",
    "\n",
    "x = ms.Tensor(0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **从NumPy数组生成**\n",
    "\n",
    "可以从NumPy数组创建张量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "<class 'mindspore.common.tensor.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([1, 0, 1, 0])\n",
    "tensor_arr = ms.Tensor(arr)\n",
    "\n",
    "print(type(arr))\n",
    "print(type(tensor_arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "初始值的类型是`numpy.ndarray`，则生成的`Tensor`数据类型与之对应。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **使用init初始化器构造张量**\n",
    "\n",
    "当使用`init`初始化器对张量进行初始化时，支持传入的参数有`init`、`shape`、`dtype`。\n",
    "\n",
    "- `init`: 支持传入[initializer](https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.common.initializer.html)的子类。\n",
    "\n",
    "- `shape`: 支持传入 `list`、`tuple`、 `int`。\n",
    "\n",
    "- `dtype`: 支持传入[mindspore.dtype](https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore/mindspore.dtype.html#mindspore.dtype)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor1:\n",
      " [[1. 1.]\n",
      " [1. 1.]]\n",
      "tensor2:\n",
      " [[-0.00128023 -0.01392901]\n",
      " [ 0.0130886  -0.00107818]]\n"
     ]
    }
   ],
   "source": [
    "import mindspore as ms\n",
    "from mindspore.common.initializer import One, Normal\n",
    "\n",
    "ms.set_seed(1)\n",
    "\n",
    "tensor1 = ms.Tensor(shape=(2, 2), dtype=ms.float32, init=One())\n",
    "# 生成一个服从正态分布 N(0.01,0.0) 的随机数组用于初始化tensor2\n",
    "tensor2 = ms.Tensor(shape=(2, 2), dtype=ms.float32, init=Normal())\n",
    "\n",
    "print(\"tensor1:\\n\", tensor1)\n",
    "print(\"tensor2:\\n\", tensor2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`init`主要用于并行模式下的延后初始化，在正常情况下不建议使用init对参数进行初始化。\n",
    "\n",
    "- **继承另一个张量的属性，形成新的张量**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1]\n",
      " [1 1]]\n",
      "input shape: (2, 2)\n",
      "output shape: (2, 2)\n"
     ]
    }
   ],
   "source": [
    "from mindspore import ops\n",
    "\n",
    "oneslike = ops.OnesLike()\n",
    "x = ms.Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))\n",
    "output = oneslike(x)\n",
    "\n",
    "print(output)\n",
    "print(\"input shape:\", x.shape)\n",
    "print(\"output shape:\", output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **输出指定大小的恒定值张量**\n",
    "\n",
    "`shape`是张量的尺寸元组，确定输出的张量的维度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "zeros = ops.Zeros()\n",
    "output = zeros((2, 2), ms.float32)\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Tensor`初始化时，可指定dtype，如`ms.int32`、`ms.float32`、`ms.bool_`等。\n",
    "\n",
    "## 张量的属性\n",
    "\n",
    "张量的属性包括形状、数据类型、转置张量、单个元素大小、占用字节数量、维数、元素个数和每一维步长。\n",
    "\n",
    "- 形状（shape）：`Tensor`的shape，是一个tuple。\n",
    "\n",
    "- 数据类型（dtype）：`Tensor`的dtype，是MindSpore的一个数据类型。\n",
    "\n",
    "- 转置张量（T）：`Tensor`的转置，是一个`Tensor`。\n",
    "\n",
    "- 单个元素大小（itemsize）： `Tensor`中每一个元素占用字节数，是一个整数。\n",
    "\n",
    "- 占用字节数量（nbytes）： `Tensor`占用的总字节数，是一个整数。\n",
    "\n",
    "- 维数（ndim）： `Tensor`的秩，也就是len(tensor.shape)，是一个整数。\n",
    "\n",
    "- 元素个数（size）： `Tensor`中所有元素的个数，是一个整数。\n",
    "\n",
    "- 每一维步长（strides）： `Tensor`每一维所需要的字节数，是一个tuple。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_shape: (2, 2)\n",
      "x_dtype: Int32\n",
      "x_transposed:\n",
      " [[1 3]\n",
      " [2 4]]\n",
      "x_itemsize: 4\n",
      "x_nbytes: 16\n",
      "x_ndim: 2\n",
      "x_size: 4\n",
      "x_strides: (8, 4)\n"
     ]
    }
   ],
   "source": [
    "x = ms.Tensor(np.array([[1, 2], [3, 4]]), ms.int32)\n",
    "\n",
    "print(\"x_shape:\", x.shape)\n",
    "print(\"x_dtype:\", x.dtype)\n",
    "print(\"x_transposed:\\n\", x.T)\n",
    "print(\"x_itemsize:\", x.itemsize)\n",
    "print(\"x_nbytes:\", x.nbytes)\n",
    "print(\"x_ndim:\", x.ndim)\n",
    "print(\"x_size:\", x.size)\n",
    "print(\"x_strides:\", x.strides)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 张量索引\n",
    "\n",
    "Tensor索引与Numpy索引类似，索引从0开始编制，负索引表示按倒序编制，冒号`:`和 `...`用于对数据进行切片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row: [0. 1.]\n",
      "value of bottom right corner: 3.0\n",
      "Last column: [1. 3.]\n",
      "First column: [0. 2.]\n"
     ]
    }
   ],
   "source": [
    "tensor = ms.Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))\n",
    "\n",
    "print(\"First row: {}\".format(tensor[0]))\n",
    "print(\"value of bottom right corner: {}\".format(tensor[1, 1]))\n",
    "print(\"Last column: {}\".format(tensor[:, -1]))\n",
    "print(\"First column: {}\".format(tensor[..., 0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 张量运算\n",
    "\n",
    "张量之间有很多运算，包括算术、线性代数、矩阵处理（转置、标引、切片）、采样等，张量运算和NumPy的使用方式类似，下面介绍其中几种操作。\n",
    "\n",
    "> 普通算术运算有：加（+）、减（-）、乘（\\*）、除（/）、取模（%）、整除（//）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add: [5. 7. 9.]\n",
      "sub: [-3. -3. -3.]\n",
      "mul: [ 4. 10. 18.]\n",
      "div: [4.  2.5 2. ]\n",
      "mod: [0. 1. 0.]\n",
      "floordiv: [4. 2. 2.]\n"
     ]
    }
   ],
   "source": [
    "x = ms.Tensor(np.array([1, 2, 3]), ms.float32)\n",
    "y = ms.Tensor(np.array([4, 5, 6]), ms.float32)\n",
    "\n",
    "output_add = x + y\n",
    "output_sub = x - y\n",
    "output_mul = x * y\n",
    "output_div = y / x\n",
    "output_mod = y % x\n",
    "output_floordiv = y // x\n",
    "\n",
    "print(\"add:\", output_add)\n",
    "print(\"sub:\", output_sub)\n",
    "print(\"mul:\", output_mul)\n",
    "print(\"div:\", output_div)\n",
    "print(\"mod:\", output_mod)\n",
    "print(\"floordiv:\", output_floordiv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Concat`将给定维度上的一系列张量连接起来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1.]\n",
      " [2. 3.]\n",
      " [4. 5.]\n",
      " [6. 7.]]\n",
      "shape:\n",
      " (4, 2)\n"
     ]
    }
   ],
   "source": [
    "data1 = ms.Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))\n",
    "data2 = ms.Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))\n",
    "op = ops.Concat()\n",
    "output = op((data1, data2))\n",
    "\n",
    "print(output)\n",
    "print(\"shape:\\n\", output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Stack`则是从另一个维度上将两个张量合并起来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0. 1.]\n",
      "  [2. 3.]]\n",
      "\n",
      " [[4. 5.]\n",
      "  [6. 7.]]]\n",
      "shape:\n",
      " (2, 2, 2)\n"
     ]
    }
   ],
   "source": [
    "data1 = ms.Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))\n",
    "data2 = ms.Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))\n",
    "op = ops.Stack()\n",
    "output = op([data1, data2])\n",
    "\n",
    "print(output)\n",
    "print(\"shape:\\n\", output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor与NumPy转换\n",
    "\n",
    "Tensor可以和NumPy进行互相转换。\n",
    "\n",
    "### Tensor转换为NumPy\n",
    "\n",
    "与张量创建相同，使用 `asnumpy()` 将Tensor变量转换为NumPy变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output: <class 'mindspore.common.tensor.Tensor'>\n",
      "n_output: <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "zeros = ops.Zeros()\n",
    "\n",
    "output = zeros((2, 2), ms.float32)\n",
    "print(\"output: {}\".format(type(output)))\n",
    "\n",
    "n_output = output.asnumpy()\n",
    "print(\"n_output: {}\".format(type(n_output)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy转换为Tensor\n",
    "\n",
    "使用`Tensor()`将NumPy变量转换为Tensor变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output: <class 'numpy.ndarray'>\n",
      "t_output: <class 'mindspore.common.tensor.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "output = np.array([1, 0, 1, 0])\n",
    "print(\"output: {}\".format(type(output)))\n",
    "\n",
    "t_output = ms.Tensor(output)\n",
    "print(\"t_output: {}\".format(type(t_output)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 稀疏张量\n",
    "\n",
    "稀疏张量是一种特殊张量，其中绝大部分元素的值为零。\n",
    "\n",
    "在某些应用场景中（比如推荐系统、分子动力学、图神经网络等），数据的特征是稀疏的，若使用普通张量表征这些数据会引入大量不必要的计算、存储和通讯开销。在这种时候就可以使用稀疏张量来表征这些数据。\n",
    "\n",
    "MindSpore现在已经支持最常用的`CSR`和`COO`两种稀疏数据格式。\n",
    "\n",
    "常用稀疏张量的表达形式是`<indices:Tensor, values:Tensor, shape:Tensor>`。其中，`indices`表示非零下标元素， `values`表示非零元素的值，shape表示的是被压缩的稀疏张量的形状。 在这个结构下，我们定义了`CSRTensor`、`COOTensor`和`RowTensor`三种稀疏张量结构。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CSRTensor\n",
    "\n",
    "`CSR`（Compressed Sparse Row）稀疏张量格式有着高效的存储与计算的优势。其中，非零元素的值存储在`values`中，非零元素的位置存储在`indptr`（行）和`indices`（列）中。其中：\n",
    "\n",
    "- `indptr`: 一维整数张量, 表示稀疏数据每一行的非零元素在`values`中的起始位置和终止位置, 索引数据类型仅支持int32。\n",
    "\n",
    "- `indices`: 一维整数张量，表示稀疏张量非零元素在列中的位置, 与`values`长度相等，索引数据类型仅支持int32。\n",
    "\n",
    "- `values`: 一维张量，表示`CSRTensor`相对应的非零元素的值，与`indices`长度相等。\n",
    "\n",
    "- `shape`: 表示的是被压缩的稀疏张量的形状，数据类型为`Tuple`,目前仅支持2维`CSRTensor`。\n",
    "\n",
    "> `CSRTensor`的详细文档，请参考[mindspore.CSRTensor](https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore/mindspore.CSRTensor.html)。\n",
    "\n",
    "下面给出一些CSRTensor的使用示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Float64\n"
     ]
    }
   ],
   "source": [
    "import mindspore as ms\n",
    "\n",
    "indptr = ms.Tensor([0, 1, 2])\n",
    "indices = ms.Tensor([0, 1])\n",
    "values = ms.Tensor([1, 2], dtype=ms.float32)\n",
    "shape = (2, 4)\n",
    "\n",
    "# CSRTensor的构建\n",
    "csr_tensor = ms.CSRTensor(indptr, indices, values, shape)\n",
    "\n",
    "print(csr_tensor.astype(ms.float64).dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述代码会生成如下式所示的`CSRTensor`:\n",
    "\n",
    "$$\n",
    " \\left[\n",
    " \\begin{matrix}\n",
    "   1 & 0 & 0 & 0 \\\\\n",
    "   0 & 2 & 0 & 0\n",
    "  \\end{matrix}\n",
    "  \\right]\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### COOTensor\n",
    "\n",
    "`COO`（Coordinate Format）稀疏张量格式用来表示某一张量在给定索引上非零元素的集合，若非零元素的个数为`N`，被压缩的张量的维数为`ndims`，则有：\n",
    "\n",
    "- `indices`: 二维整数张量，每行代表非零元素下标。形状：`[N, ndims]`， 索引数据类型仅支持int32。\n",
    "\n",
    "- `values`: 一维张量，表示相对应的非零元素的值。形状：`[N]`。\n",
    "\n",
    "- `shape`: 表示的是被压缩的稀疏张量的形状，目前仅支持2维`COOTensor`。\n",
    "\n",
    "> `COOTensor`的详细文档，请参考[mindspore.COOTensor](https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore/mindspore.COOTensor.html)。\n",
    "\n",
    "下面给出一些COOTensor的使用示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2.]\n",
      "[[0 1]\n",
      " [1 2]]\n",
      "(3, 4)\n",
      "Float64\n"
     ]
    }
   ],
   "source": [
    "import mindspore as ms\n",
    "import mindspore.nn as nn\n",
    "\n",
    "indices = ms.Tensor([[0, 1], [1, 2]], dtype=ms.int32)\n",
    "values = ms.Tensor([1, 2], dtype=ms.float32)\n",
    "shape = (3, 4)\n",
    "\n",
    "# COOTensor的构建\n",
    "coo_tensor = ms.COOTensor(indices, values, shape)\n",
    "\n",
    "print(coo_tensor.values)\n",
    "print(coo_tensor.indices)\n",
    "print(coo_tensor.shape)\n",
    "print(coo_tensor.astype(ms.float64).dtype)  # COOTensor转换数据类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述代码会生成如下式所示的`COOTensor`:\n",
    "\n",
    "$$\n",
    " \\left[\n",
    " \\begin{matrix}\n",
    "   0 & 1 & 0 & 0 \\\\\n",
    "   0 & 0 & 2 & 0 \\\\\n",
    "   0 & 0 & 0 & 0\n",
    "  \\end{matrix}\n",
    "  \\right]\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RowTensor\n",
    "\n",
    "`RowTensor`用于压缩第零个维度稀疏的张量。若`RowTensor`的维度为`[L0, D1, D2, ..., DN ]`。第零维度的非零元素个数为`D0`, 则有`L0 >> D0`。\n",
    "\n",
    "- `indices`: 一维整数张量，表示稀疏张量第零维度中非零元素的位置，形状为`[D0]`。\n",
    "\n",
    "- `values`: 表示相对应的非零元素的值，形状为`[D0, D1, D2, ..., DN]`。\n",
    "\n",
    "- `dense_shape`: 表示的是被压缩的稀疏张量的形状。\n",
    "\n",
    "> `RowTensor`的详细文档，请参考[mindspore.RowTensor](https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore/mindspore.RowTensor.html)。代码样例如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "non-zero values: [[1. 2.]]\n",
      "non-zero indices: [0]\n",
      "shape: (3, 2)\n"
     ]
    }
   ],
   "source": [
    "import mindspore as ms\n",
    "import mindspore.nn as nn\n",
    "\n",
    "class Net(nn.Cell):\n",
    "    def __init__(self, dense_shape):\n",
    "        super(Net, self).__init__()\n",
    "        self.dense_shape = dense_shape\n",
    "\n",
    "    def construct(self, indices, values):\n",
    "        x = ms.RowTensor(indices, values, self.dense_shape)\n",
    "        return x.values, x.indices, x.dense_shape\n",
    "\n",
    "indices = ms.Tensor([0])\n",
    "values = ms.Tensor([[1, 2]], dtype=ms.float32)\n",
    "out = Net((3, 2))(indices, values)\n",
    "\n",
    "print(\"non-zero values:\", out[0])\n",
    "print(\"non-zero indices:\", out[1])\n",
    "print(\"shape:\", out[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述代码会生成如下式所示的`RowTensor`:\n",
    "\n",
    "$$\n",
    " \\left[\n",
    " \\begin{matrix}\n",
    "   1 & 2 \\\\\n",
    "   0 & 0 \\\\\n",
    "   0 & 0\n",
    "  \\end{matrix}\n",
    "  \\right]\n",
    "$$\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MindSpore",
   "language": "python",
   "name": "mindspore"
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}