记录一下，如果文章在文件夹里改名字了，要再打开一次，要不然vscode里改的bug不影响这个文件。。。

前置知识

使用Tensor来处理数据

“tensor”这个单词一般可译作“张量”，张量可以看作是一个多维数组。标量可以看作是0维张量，向量可以看作1维张量，矩阵可以看作是二维张量。

Tensor概念解释

飞桨使用张量（Tensor）来表示神经网络中传递的数据
Tensor 可以理解为多维数组，类似于 Numpy 数组（ndarray）的概念
与 Numpy 数组相比，Tensor 除了支持运行在 CPU 上，还支持运行在 GPU 及各种 AI 芯片上，以实现计算加速
飞桨基于 Tensor，实现了深度学习所必须的反向传播功能和多种多样的组网算子，从而可更快捷地实现深度学习组网与训练等功能

Tensor的创建

指定数据创建

与 Numpy 创建数组方式类似，通过给定 Python 序列（如列表 list、元组 tuple），可使用 paddle.to_tensor 创建任意维度的 Tensor

创建类似向量的1维Tensor

>>> import paddle
>>> ndim_1_Tensor = paddle.to_tensor([2.0, 3.0, 4.0])
>>> print(ndim_1_Tensor)
Tensor(shape=[3], dtype=float32, place=Place(gpu:0), stop_gradient=True,
    [2., 3., 4.])

ndim:维度
如果仅输入单个标量（scalar）数据（例如 float/int/bool 类型的单个元素），则会创建形状为 [1] 的 Tensor，即 0 维 Tensor：

>>> paddle.to_tensor(2)
Tensor(shape=[], dtype=int64, place=Place(gpu:0), stop_gradient=True,
    2)


>>> paddle.to_tensor([2])
Tensor(shape=[1], dtype=int64, place=Place(gpu:0), stop_gradient=True,
    [2])

这两个有区别，维度不同，一个0维，一个1维

创建类似矩阵的2维Tensor

>>> ndim_2_Tensor = paddle.to_tensor([[1,2,3],[2,3,4]])
>>> print(ndim_2_Tensor)
Tensor(shape=[2, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True,
    [[1, 2, 3],
        [2, 3, 4]])


>>> ndim_2_Tensor = paddle.to_tensor([[1.0,2.0,3.0],[2,3,4]])
>>> print(ndim_2_Tensor)
Tensor(shape=[2, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True,
    [[1., 2., 3.],
        [2., 3., 4.]])


>>> ndim_2_Tensor = paddle.to_tensor([[1.0,2.0,3.0],[2.0,3.0,4.0]])
>>> print(ndim_2_Tensor)
Tensor(shape=[2, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True,
    [[1., 2., 3.],
        [2., 3., 4.]])

创建3维Tensor

>>> ndim_3_Tensor = paddle.to_tensor([[[1,2,3],[2,3,4]],[[3,4,5],[4,5,6]]])
>>> print(ndim_3_Tensor)
Tensor(shape=[2, 2, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True,
    [[[1, 2, 3],
        [2, 3, 4]],

        [[3, 4, 5],
        [4, 5, 6]]])

上述不同维度的 Tensor 可视化的表示如下图所示(数据可能不同，看个图示就行)：

需要注意的是，Tensor 必须形如矩形，即在任何一个维度上，元素的数量必须相等，否则会抛出异常，示例如下：
1
2
3
4
5
6
7
8
9
10
>>> x = paddle.to_tensor([[1,2,3],[1,2]])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "C:\Users\lxcqm\anaconda3\envs\Paddle_Py3.12\Lib\site-packages\paddle\tensor\creation.py", line 794, in to_tensor
    return _to_tensor_non_static(data, dtype, place, stop_gradient)
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\lxcqm\anaconda3\envs\Paddle_Py3.12\Lib\site-packages\paddle\tensor\creation.py", line 577, in _to_tensor_non_static
    data = np.array(data)
        ^^^^^^^^^^^^^^
ValueError: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.
说明：

飞桨也支持将 Tensor 转换为 Python 序列数据，可通过 paddle.tolist 实现，飞桨实际的转换处理过程是 Python 序列 <-> Numpy 数组 <-> Tensor。

基于给定数据创建 Tensor 时，飞桨是通过拷贝方式创建，与原始数据不共享内存。

指定形状创建

如果要创建一个指定形状的 Tensor，可以使用 paddle.zeros、paddle.ones、paddle.full 实现：

>>> paddle.zeros([2,3])
W0314 17:10:06.231387  9012 gpu_resources.cc:119] Please NOTE: device: 0, GPU Compute Capability: 8.9, Driver API Version: 12.4, Runtime API Version: 12.0
W0314 17:10:08.771996  9012 gpu_resources.cc:164] device: 0, cuDNN Version: 8.9.
Tensor(shape=[2, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[0., 0., 0.],
        [0., 0., 0.]])

>>> paddle.ones([2,3])
Tensor(shape=[2, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[1., 1., 1.],
        [1., 1., 1.]])

>>> paddle.twos([2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'paddle' has no attribute 'twos'

>>> paddle.full([2,4],4)
Tensor(shape=[2, 4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[4., 4., 4., 4.],
        [4., 4., 4., 4.]])

指定区间创建

1
2

paddle.arange(start, end, step)  # 创建以步长 step 均匀分隔区间[start, end)的 Tensor
paddle.linspace(start, stop, num) # 创建以元素个数 num 均匀分隔区间[start, stop)的 Tensor

实例:

1
2
3

>>> paddle.arange(start=1, end=10, step = 2)
Tensor(shape=[5], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [1, 3, 5, 7, 9])

>>> paddle.linspace(start=1,stop=10,num=3)
Tensor(shape=[3], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [1.        , 5.50000000, 10.       ])


>>> paddle.linspace(start=0,stop=10,num=3)
Tensor(shape=[3], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [0. , 5. , 10.])

说明：
除了以上指定数据、形状、区间创建 Tensor 的方法，飞桨还支持如下类似的创建方式，如：

创建一个空 Tensor，即根据 shape 和 dtype 创建尚未初始化元素值的 Tensor，可通过 paddle.empty 实现。

创建一个与其他 Tensor 具有相同 shape 与 dtype 的 Tensor，可通过 paddle.ones_like 、 paddle.zeros_like 、 paddle.full_like 、paddle.empty_like 实现。

拷贝并创建一个与其他 Tensor 完全相同的 Tensor，可通过 paddle.clone 实现。

创建一个满足特定分布的 Tensor，如 paddle.rand, paddle.randn , paddle.randint 等。

通过设置随机种子创建 Tensor，可每次生成相同元素值的随机数 Tensor，可通过 paddle.seed 和 paddle.rand 组合实现。

指定图像/文本数据创建

在常见深度学习任务中，数据样本可能是图片（image）、文本（text）、语音（audio）等多种类型，在送入神经网络训练或推理前，这些数据和对应的标签均需要创建为 Tensor。以下是图像场景和 NLP(自然语言处理) 场景中手动转换 Tensor 方法的介绍。

对于图像场景，可使用 paddle.vision.transforms.ToTensor 直接将 PIL.Image 格式的数据转为 Tensor，使用 paddle.to_tensor 将图像的标签（Label，通常是 Python 或 Numpy 格式的数据）转为 Tensor。
对于文本场景，需将文本数据解码为数字后，再通过 paddle.to_tensor 转为 Tensor。不同文本任务标签形式不一样，有的任务标签也是文本，有的则是数字，均需最终通过 paddle.to_tensor 转为 Tensor。

下面以图像场景为例介绍，以下示例代码中将随机生成的图片转换为 Tensor:

import numpy as np
from PIL import Image
import paddle.vision.transforms as T
import paddle.vision.transforms.functional as F

fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) # 创建随机图片
fake_img.show()
transform = T.ToTensor()
tensor = transform(fake_img) # 使用 ToTensor()将图片转换为 Tensor
print(tensor)

输出:

(Paddle_Py3.12) C:\Users\lxcqm>python D:\PyTorch\Pytorch1\main.py
W0314 17:25:22.979338 34280 gpu_resources.cc:119] Please NOTE: device: 0, GPU Compute Capability: 8.9, Driver API Version: 12.4, Runtime API Version: 12.0
W0314 17:25:22.984452 34280 gpu_resources.cc:164] device: 0, cuDNN Version: 8.9.
Tensor(shape=[3, 224, 224], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[[0.05098040, 0.00392157, 0.09019608, ..., 0.48627454,
          0.25882354, 0.21960786],
         [0.77254909, 0.82352948, 0.12549020, ..., 0.29411766,
          0.47450984, 0.99215692],
         [0.50980395, 0.90588242, 0.86666673, ..., 0.94509810,
          0.73725492, 0.40784317],
         ...,
         [0.59215689, 0.96470594, 0.12549020, ..., 0.43529415,
          0.34117648, 0.25490198],
         [0.27843139, 0.50196081, 0.22745100, ..., 0.70588237,
          0.95294124, 0.57647061],
         [0.20784315, 0.70588237, 0.88235301, ..., 0.55294120,
          0.77254909, 0.16078432]],

        [[0.28235295, 0.54117650, 0.21960786, ..., 0.47450984,
          0.32941177, 0.95294124],
         [0.22352943, 0.68627453, 0.76470596, ..., 0.51764709,
          0.55294120, 0.96470594],
         [0.23921570, 0.79607850, 0.48627454, ..., 0.51764709,
          0.20000002, 0.80392164],
         ...,
         [0.09411766, 0.49019611, 0.83529419, ..., 0.43137258,
          0.76862752, 0.26666668],
         [0.99607849, 0.09411766, 0.81960791, ..., 0.54117650,
          0.27843139, 0.92549026],
         [0.20000002, 0.47058827, 0.05882353, ..., 0.41176474,
          0.41960788, 0.30196080]],

        [[0.86666673, 0.46274513, 0.13333334, ..., 0.80000007,
          0.34509805, 0.13333334],
         [0.47843140, 0.14509805, 0.41960788, ..., 0.73725492,
          0.18823531, 0.42745101],
         [0.11372550, 0.73725492, 0.65490198, ..., 0.86666673,
          0.25490198, 0.83137262],
         ...,
         [0.94901967, 0.45490199, 0.08235294, ..., 0.85882360,
          0.14901961, 0.14117648],
         [0.03137255, 0.72549021, 0.51372552, ..., 0.35686275,
          0.24313727, 0.01176471],
         [0.12941177, 0.24705884, 0.97254908, ..., 0.65098041,
          0.00784314, 0.96470594]]])

说明：
实际编码时，由于飞桨数据加载的 paddle.io.DataLoader API 能够将原始 paddle.io.Dataset 定义的数据自动转换为 Tensor，所以可以不做手动转换。具体如下节介绍。

自动创建Tensor的功能介绍

除了手动创建 Tensor 外，实际在飞桨框架中有一些 API 封装了 Tensor 创建的操作，从而无需用户手动创建 Tensor。例如 paddle.io.DataLoader 能够基于原始 Dataset，返回读取 Dataset 数据的迭代器，迭代器返回的数据中的每个元素都是一个 Tensor。另外在一些高层 API，如 paddle.Model.fit 、paddle.Model.predict ，如果传入的数据不是 Tensor，会自动转为 Tensor 再进行模型训练或推理。

说明：
paddle.Model.fit、paddle.Model.predict 等高层 API 支持传入 Dataset 或 DataLoader，如果传入的是 Dataset，那么会用 DataLoader 封装转为 Tensor 数据；如果传入的是 DataLoader，则直接从 DataLoader 迭代读取 Tensor 数据送入模型训练或推理。因此即使没有写将数据转为 Tensor 的代码，也能正常执行，提升了编程效率和容错性。

以下示例代码中，分别打印了原始数据集的数据，和送入 DataLoader 后返回的数据，可以看到数据结构由 Python list 转为了 Tensor:

Compose&Normalize

Compose:
- Compose 是一个组合多个图像变换的工具。你可以将多个变换（transforms）放入一个列表中，然后传递给 Compose。当你应用这个组合变换到一个图像上时，这些变换会按照列表中的顺序一个接一个地应用到图像上。
- 例如，如果你想先对图像进行归一化，然后再将其转换为 Tensor，你可以这样做：
  1
  2
  3
  4
  transforms = Compose([
  Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
  ToTensor()
  ])
Normalize:
- Normalize 用于对图像进行标准化。在深度学习中，我们经常对输入数据进行标准化，使其具有零均值和单位方差，这有助于模型的训练。
- Normalize 需要两个参数：mean 和 std，分别代表每个通道的均值和标准差。对于 RGB 图像，这三个通道分别是红色、绿色和蓝色。
- 在上面的例子中，我们使用了 [0.5, 0.5, 0.5] 作为均值和 [0.5, 0.5, 0.5] 作为标准差，这实际上是将图像的像素值从 [0, 1] 范围转换到 [-1, 1] 范围。

总之，Compose 和 Normalize 是 PaddlePaddle 中非常有用的工具，用于图像预处理和增强。

import paddle
from paddle.vision.transforms import Compose,Normalize

transform = Compose([Normalize(mean=[127.5], std=[127.5], data_format='CHW')])
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=transform)
print(test_dataset[0][1])
loader = paddle.io.DataLoader(test_dataset)
for data in enumerate(loader):
    x, label = data[1]
    print(label)
    break

输出:

(Paddle_Py3.12) C:\Users\lxcqm>python D:\PyTorch\Pytorch1\main.py
[7]  # 原始数据中 label 为 Python list
Tensor(shape=[1, 1], dtype=int64, place=Place(gpu_pinned), stop_gradient=True,
       [[7]])   # 由 DataLoader 转换后，label 为 Tensor

Tensor的属性

在前文中，可以看到打印 Tensor 时有 shape、dtype、place 等信息，这些都是 Tensor 的重要属性，想要了解如何操作 Tensor 需要对其属性有一定了解，接下来分别展开介绍 Tensor 的属性相关概念:

1 2	Tensor(shape=[3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [2., 3., 4.])

Tensor的形状

形状的介绍
形状是 Tensor 的一个重要的基础属性，可以通过 Tensor.shape 查看一个 Tensor 的形状，以下为相关概念：

shape：描述了 Tensor 每个维度上元素的数量。
ndim： Tensor 的维度数量，例如向量的维度为 1，矩阵的维度为 2，Tensor 可以有任意数量的维度。
axis 或者 dimension：Tensor 的轴，即某个特定的维度。
size：Tensor 中全部元素的个数。

创建 1 个四维 Tensor ，并通过图形来直观表达以上几个概念之间的关系：

1	ndim_4_Tensor = paddle.ones([2, 3, 4, 5])

axis0:2的意思是0轴，数值为2

import paddle

ndim_4_Tensor = paddle.ones([2, 3, 4, 5])

print("Data Type of every element:", ndim_4_Tensor.dtype)
print("Number of dimensions:", ndim_4_Tensor.ndim)
print("Shape of Tensor:", ndim_4_Tensor.shape)
print("Elements number along axis 0 of Tensor:", ndim_4_Tensor.shape[0])
print("Elements number along the last axis of Tensor:", ndim_4_Tensor.shape[-1])

输出:

(Paddle_Py3.12) C:\Users\lxcqm>python D:\PyTorch\Pytorch1\main.py
W0314 18:05:09.299489  8612 gpu_resources.cc:119] Please NOTE: device: 0, GPU Compute Capability: 8.9, Driver API Version: 12.4, Runtime API Version: 12.0
W0314 18:05:09.303498  8612 gpu_resources.cc:164] device: 0, cuDNN Version: 8.9.
Data Type of every element: paddle.float32
Number of dimensions: 4
Shape of Tensor: [2, 3, 4, 5]
Elements number along axis 0 of Tensor: 2
Elements number along the last axis of Tensor: 5

重置 Tensor 形状（Reshape）的方法

import paddle

ndim_1_Tensor = paddle.to_tensor([1, 2, 3])
print("origina:")
print(ndim_1_Tensor)
print("the shape of ndim_1_Tensor:", ndim_1_Tensor.shape)

reshape_Tensor = paddle.reshape(ndim_1_Tensor, [3, 1])
print("[3, 1]:")
print(reshape_Tensor)
print("After reshape:", reshape_Tensor.shape)

reshape_Tensor = paddle.reshape(ndim_1_Tensor, [1, 3])
print("[1, 3]:")
print(reshape_Tensor)
print("After reshape:", reshape_Tensor.shape)

输出:

original:
Tensor(shape=[3], dtype=int64, place=Place(gpu:0), stop_gradient=True,
    [1, 2, 3])
the shape of ndim_1_Tensor: [3]
[3, 1]:
Tensor(shape=[3, 1], dtype=int64, place=Place(gpu:0), stop_gradient=True,
    [[1],
        [2],
        [3]])
After reshape: [3, 1]
[1, 3]:
Tensor(shape=[1, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True,
    [[1, 2, 3]])
After reshape: [1, 3]

在指定新的 shape 时存在一些技巧：
-1表示这个维度的值是从 Tensor 的元素总数和剩余维度自动推断出来的。因此，有且只有一个维度可以被设置为 -1。
0 表示该维度的元素数量与原值相同，因此 shape 中 0 的索引值必须小于 Tensor 的维度（索引值从 0 开始计，如第 1 维的索引值是 0，第二维的索引值是 1）。
通过几个例子来详细了解：
origin代表原始形状
1
2
3
4
5
6
7
8
9
10
origin:[3, 2, 5] reshape:[3, 10]      actual: [3, 10] # 直接指定目标 shape

origin:[3, 2, 5] reshape:[-1]         actual: [30] # 转换为 1 维，维度根据元素总数推断出来是 3*2*5=30

origin:[3, 2, 5] reshape:[-1, 5]      actual: [6, 5] # 转换为 2 维，固定一个维度 5，另一个维度根据元素总数推断出来是 30÷5=6

origin:[3, 2, 5] reshape:[0, -1]      actual: [3, 10] # reshape:[0, -1]中 0 的索引值为 0，按照规则，转换后第 0 维的元素数量与原始 Tensor 第 0 维的元素数量相同，为 3；第 1 维的元素数量根据元素总值计算得出为 30÷3=10。

origin:[3, 2]    reshape:[3, 1, 0]    error： # reshape:[3, 1, 0]中 0 的索引值为 2，但原 Tensor 只有 2 维，无法找到与第 3 维对应的元素数量，因此出错。
从上面的例子可以看到，通过 reshape:[-1] ，可以很方便地将 Tensor 按其在计算机上的内存分布展平为一维。
1
2
3
4
5
6
7
import paddle

ndim_3_Tensor = paddle.to_tensor([[[1, 2, 3, 4, 5],
                                [6, 7, 8, 9, 10]],
                                [[11, 12, 13, 14, 15],
                                [16, 17, 18, 19, 20]]])
print("Tensor flattened to Vector:", paddle.reshape(ndim_3_Tensor, [-1]).numpy())
输出:
1
Tensor flattened to Vector: [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]
说明：
除了 paddle.reshape 可重置 Tensor 的形状，还可通过如下方法改变 shape：

paddle.squeeze，可实现 Tensor 的降维操作，即把 Tensor 中尺寸为 1 的维度删除。

paddle.unsqueeze，可实现 Tensor 的升维操作，即向 Tensor 中某个位置插入尺寸为 1 的维度。

paddle.flatten，将 Tensor 的数据在指定的连续维度上展平。

paddle.transpose，对 Tensor 的数据进行重排。

原位（Inplace）操作和非原位操作的区别

课程笔记

创建一个tensor

import paddle

x = paddle.arange(12)
print(x)
print(x.shape)  #the shape of the tensor
print(x.numel())    #the num element of the tensor

OUT

Tensor(shape=[12], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10, 11])
[12]
Tensor(shape=[], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       12)

改变张量形状

import paddle

x = paddle.arange(12)

y = paddle.reshape(x, [3, 4])

print(y)

OUT

Tensor(shape=[3, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0 , 1 , 2 , 3 ],
        [4 , 5 , 6 , 7 ],
        [8 , 9 , 10, 11]])

tensor的计算

import paddle

x = paddle.to_tensor([1.0, 2, 4, 8])
y = paddle.to_tensor([2, 2, 2, 2])

print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x ** y)  # 求幂

OUT

Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [3. , 4. , 6. , 10.])
Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [-1.,  0.,  2.,  6.])
Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [2. , 4. , 8. , 16.])
Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [0.50000000, 1.        , 2.        , 4.        ])
Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [1. , 4. , 16., 64.])

tensor的连结

import paddle

x = paddle.arange(12, dtype=paddle.float32).reshape([3, 4])#[]也可以写成()
y = paddle.to_tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

print(paddle.concat((x, y), axis=0))#第一个维度

OUT

Tensor(shape=[6, 4], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[0. , 1. , 2. , 3. ],
        [4. , 5. , 6. , 7. ],
        [8. , 9. , 10., 11.],
        [2. , 1. , 4. , 3. ],
        [1. , 2. , 3. , 4. ],
        [4. , 3. , 2. , 1. ]])

import paddle

x = paddle.arange(12, dtype=paddle.float32).reshape([3, 4])
y = paddle.to_tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

print(paddle.concat((x, y), axis=-1))#最后一个维度

OUT

Tensor(shape=[3, 8], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[0. , 1. , 2. , 3. , 2. , 1. , 4. , 3. ],
        [4. , 5. , 6. , 7. , 1. , 2. , 3. , 4. ],
        [8. , 9. , 10., 11., 4. , 3. , 2. , 1. ]])

通过逻辑运算符构建二维tensor

import paddle

x = paddle.arange(12, dtype=paddle.float32).reshape([3, 4])
y = paddle.to_tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

z = x == y
print(z)

OUT

Tensor(shape=[3, 4], dtype=bool, place=Place(gpu:0), stop_gradient=True,
       [[False, True , False, True ],
        [False, False, False, False],
        [False, False, False, False]])

求和产生一个元素的张量

import paddle

x = paddle.arange(12, dtype=paddle.float32).reshape([3, 4])

print(x.sum())

OUT

1 2	Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, 66.)

1
2
3

y = paddle.to_tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

print(sum(y))

OUT

1 2	Tensor(shape=[4], dtype=float32, place=Place(gpu:0), stop_gradient=True, [7., 6., 9., 8.])

广播机制

import paddle

x = paddle.arange(3).reshape([3, 1])
y = paddle.arange(2).reshape([1, 2])
print(x)
print(y)
print(x+y)

OUT

Tensor(shape=[3, 1], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0],
        [1],
        [2]])
Tensor(shape=[1, 2], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0, 1]])
Tensor(shape=[3, 2], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0, 1],
        [1, 2],
        [2, 3]])

访问元素

import paddle

x = paddle.arange(3).reshape([3, 1])

print(x[0:2])

OUT

1
2
3

Tensor(shape=[2, 1], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0],
        [1]])

赋值矩阵中的元素

赋值单个元素

import paddle

x = paddle.arange(3).reshape([3, 1])

print(x)

x[1, 0] = 5
print(x)

OUT

Tensor(shape=[3, 1], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0],
        [1],
        [2]])
Tensor(shape=[3, 1], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0],
        [5],
        [2]])

赋值多个元素

import paddle

x = paddle.arange(12).reshape([3, 4])

print(x)

x[0:2, :] = 99
print(x)

OUT

Tensor(shape=[3, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[0 , 1 , 2 , 3 ],
        [4 , 5 , 6 , 7 ],
        [8 , 9 , 10, 11]])
Tensor(shape=[3, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True,
       [[99, 99, 99, 99],
        [99, 99, 99, 99],
        [8 , 9 , 10, 11]])

Hello！Welcom to Tumy-Time！

前置知识

使用Tensor来处理数据

Tensor概念解释

Tensor的创建

指定数据创建

指定形状创建

指定区间创建

指定图像/文本数据创建

自动创建Tensor的功能介绍

Tensor的属性

Tensor的形状

课程笔记

创建一个tensor

改变张量形状

tensor的计算

tensor的连结

通过逻辑运算符构建二维tensor

求和产生一个元素的张量

广播机制

访问元素

赋值矩阵中的元素

赋值单个元素

赋值多个元素

为新结果分配内存

你的赏识是我前进的动力