{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.9.0/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/r2.9.0/tutorials/zh_cn/beginner/mindspore_tensor.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.9.0/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/r2.9.0/tutorials/zh_cn/beginner/mindspore_tensor.py)\n",
    " [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.9.0/resource/_static/logo_source.svg)](https://atomgit.com/mindspore/docs/blob/r2.9.0/tutorials/source_zh_cn/beginner/tensor.ipynb)\n",
    "\n",
    "[基本介绍](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/introduction.html) || [快速入门](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/quick_start.html) || **张量 Tensor** || [数据加载与处理](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/dataset.html) || [网络构建](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/model.html) || [函数式自动微分](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/autograd.html) || [模型训练](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/train.html) || [保存与加载](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/save_load.html) || [Graph Mode加速](https://www.mindspore.cn/tutorials/zh-CN/r2.9.0/beginner/accelerate_with_static_graph.html) ||"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 张量 Tensor\n",
    "\n",
    "张量（Tensor）是一个多线性函数，可用于表示矢量、标量和其他张量之间的线性关系。常见的线性关系包括内积、外积、线性映射以及笛卡儿积等。张量的坐标在 $n$ 维空间内，有  $n^{r}$ 个分量，每个分量都是坐标的函数。在坐标变换时，这些分量也依照某些规则作线性变换。$r$ 称为该张量的秩或阶（与矩阵的秩和阶无关）。\n",
    "\n",
    "张量是一种特殊的数据结构，与数组和矩阵非常相似。张量（[Tensor](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore/mindspore.Tensor.html)）是MindSpore网络运算中的基本数据结构，本教程主要介绍张量的属性及用法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import mindspore\n",
    "from mindspore import Tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建张量\n",
    "\n",
    "张量的创建方式有多种，构造张量时，支持传入`Tensor`、`float`、`int`、`bool`、`tuple`、`list`和`numpy.ndarray`类型。\n",
    "\n",
    "- **根据数据直接生成**\n",
    "\n",
    "    可以根据数据创建张量。数据类型可以手动设置，也可以由框架自动推断。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 1 0] (4,) Int64\n"
     ]
    }
   ],
   "source": [
    "data = [1, 0, 1, 0]\n",
    "x_data = mindspore.tensor(data)\n",
    "print(x_data, x_data.shape, x_data.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **从NumPy数组生成**\n",
    "\n",
    "    可以从NumPy数组创建张量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 1 0] (4,)\n"
     ]
    }
   ],
   "source": [
    "np_array = np.array(data)\n",
    "x_from_np = mindspore.tensor(np_array)\n",
    "print(x_from_np, x_from_np.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **使用init初始化器构造张量**\n",
    "\n",
    "    当使用`init`初始化器对张量进行初始化时，支持传入的参数有`init`、`shape`、`dtype`。\n",
    "\n",
    "    - `init`: 支持传入[initializer](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore.common.initializer.html)的子类。如：下方示例中的 [One()](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore.common.initializer.html#mindspore.common.initializer.One) 和 [Normal()](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore.common.initializer.html#mindspore.common.initializer.Normal)。\n",
    "\n",
    "    - `shape`: 支持传入 `list`、`tuple`、 `int`。\n",
    "\n",
    "    - `dtype`: 支持传入[mindspore.dtype](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore/mindspore.dtype.html#mindspore.dtype)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor1:\n",
      " [[1. 1.]\n",
      " [1. 1.]]\n",
      "tensor2:\n",
      " [[-0.0107513   0.00407822]\n",
      " [-0.00113699  0.00081491]]\n"
     ]
    }
   ],
   "source": [
    "from mindspore.common.initializer import One, Normal\n",
    "\n",
    "# Initialize a tensor with ones\n",
    "tensor1 = mindspore.tensor(shape=(2, 2), dtype=mindspore.float32, init=One()).init_data()\n",
    "# Initialize a tensor from normal distribution\n",
    "tensor2 = mindspore.tensor(shape=(2, 2), dtype=mindspore.float32, init=Normal()).init_data()\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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ones Tensor: \n",
      " [1 1 1 1] \n",
      "\n",
      "Zeros Tensor: \n",
      " [0 0 0 0] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "from mindspore import ops\n",
    "\n",
    "x_ones = ops.ones_like(x_data)\n",
    "print(f\"Ones Tensor: \\n {x_ones} \\n\")\n",
    "\n",
    "x_zeros = ops.zeros_like(x_data)\n",
    "print(f\"Zeros Tensor: \\n {x_zeros} \\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 张量的属性\n",
    "\n",
    "张量的属性包括形状、数据类型、转置张量、单个元素大小、占用字节数量、维数、元素个数和每一维步长。\n",
    "\n",
    "- 形状（shape）：`Tensor`的shape，为tuple类型。\n",
    "\n",
    "- 数据类型（dtype）：`Tensor`的dtype，是MindSpore的一个数据类型。\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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_shape: (2, 2)\n",
      "x_dtype: Int32\n",
      "x_itemsize: 4\n",
      "x_nbytes: 16\n",
      "x_ndim: 2\n",
      "x_size: 4\n",
      "x_strides: (8, 4)\n"
     ]
    }
   ],
   "source": [
    "x = mindspore.tensor(np.array([[1, 2], [3, 4]]), mindspore.int32)\n",
    "\n",
    "print(\"x_shape:\", x.shape)\n",
    "print(\"x_dtype:\", x.dtype)\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": 7,
   "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 = mindspore.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": 8,
   "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 = mindspore.tensor(np.array([1, 2, 3]), mindspore.float32)\n",
    "y = mindspore.tensor(np.array([4, 5, 6]), mindspore.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](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/ops/mindspore.ops.concat.html)将给定维度上的一系列张量连接起来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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 = mindspore.tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))\n",
    "data2 = mindspore.tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))\n",
    "output = ops.concat((data1, data2), axis=0)\n",
    "\n",
    "print(output)\n",
    "print(\"shape:\\n\", output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[stack](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/ops/mindspore.ops.stack.html) 则是从另一个维度上将两个张量合并起来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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 = mindspore.tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))\n",
    "data2 = mindspore.tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))\n",
    "output = ops.stack([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",
    "可以使用 [Tensor.asnumpy()](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore/Tensor/mindspore.Tensor.asnumpy.html) 将MindSpore的Tensor转换为NumPy数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t: [1. 1. 1. 1. 1.] <class 'mindspore.common.tensor.Tensor'>\n",
      "n: [1. 1. 1. 1. 1.] <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "t = mindspore.tensor([1., 1., 1., 1., 1.])\n",
    "print(f\"t: {t}\", type(t))\n",
    "n = t.asnumpy()\n",
    "print(f\"n: {n}\", type(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy转换为Tensor\n",
    "\n",
    "使用 [Tensor.from_numpy()](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore/Tensor/mindspore.Tensor.asnumpy.html) 将NumPy数据转换为MindSpore的Tensor。此方法不拷贝数据，共用数据存储地址，速度较快，但NumPy数据需为连续（用numpy.iscontiguous()判断）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = np.ones(5)\n",
    "t = Tensor.from_numpy(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n: [2. 2. 2. 2. 2.] <class 'numpy.ndarray'>\n",
      "t: [2. 2. 2. 2. 2.] <class 'mindspore.common.tensor.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "np.add(n, 1, out=n)\n",
    "print(f\"n: {n}\", type(n))\n",
    "print(f\"t: {t}\", type(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 [mindspore.tensor](https://www.mindspore.cn/docs/zh-CN/r2.9.0/api_python/mindspore/mindspore.tensor.html) 直接创建，此方法会对数据进行拷贝。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = np.ones(5)\n",
    "t = mindspore.tensor(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n: [2. 2. 2. 2. 2.] <class 'numpy.ndarray'>\n",
      "t: [1. 1. 1. 1. 1.] <class 'mindspore.common.tensor.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "np.add(n, 1, out=n)\n",
    "print(f\"n: {n}\", type(n))\n",
    "print(f\"t: {t}\", type(t))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ms25-kernel",
   "language": "python",
   "name": "ms25-kernel"
  },
  "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.21"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}