paddle-基本数据结构_paddle代码结构

import paddle
import numpy as np
from PIL import Image
import paddle.vision.transforms as T
import paddle.vision.transforms.functional as F
from paddle.vision.transforms import Compose, Normalize
 
## Tensor 的创建
# 指定值创建1维张量
ndim_1_Tensor = paddle.to_tensor([2.0, 3.0, 4.0])
print(ndim_1_Tensor)
 
# 单标量 0 维张量
ndim_2_Tensor = paddle.to_tensor(2)
ndim_3_Tensor = paddle.to_tensor([2])
print(ndim_2_Tensor)
print(ndim_3_Tensor)
 
# 指定值创建 2 维张量
ndim_4_Tensor = paddle.to_tensor(
    [[1.0, 2.0, 3.0],
     [4.0, 5.0, 6.0]
     ])
print(ndim_4_Tensor)
 
# 指定值创建 3 维张量
ndim_5_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(ndim_5_Tensor)
 
# 指定形状创建
m = n = 4
ndim_6_Tensor = paddle.zeros([m, n])             # 创建数据全为 0，形状为 [m, n] 的 Tensor
ndim_7_Tensor = paddle.ones([m, n])              # 创建数据全为 1，形状为 [m, n] 的 Tensor
ndim_8_Tensor = paddle.full([m, n], 10)          # 创建数据全为 10，形状为 [m, n] 的 Tensor
print(ndim_6_Tensor)
print(ndim_7_Tensor)
print(ndim_8_Tensor)
 
# 指定区间创建
# start：起始数     end:截止数(不含)    step:步距
ndim_9_Tensor = paddle.arange(start = 1, end = 100, step = 3)
# start：起始数     stop：截止数        num：需要的元素数
ndim_10_Tensor = paddle.linspace(start = 1, stop = 100, num = 10)
print(ndim_9_Tensor)
print(ndim_10_Tensor)
 
# 创建空张量
ndim_11_Tensor = paddle.empty(shape=[3, 3], dtype='float32')
# 创建一个与其他 Tensor 具有相同 shape 与 dtype 的 Tensor
ndim_12_Tensor = paddle.ones_like(ndim_11_Tensor)                   # 1
ndim_13_Tensor = paddle.ones_like(ndim_11_Tensor, dtype='int32')    # 1
ndim_14_Tensor = paddle.zeros_like(ndim_11_Tensor)                  # 0
ndim_15_Tensor = paddle.full_like(ndim_11_Tensor, 99)               # 99
ndim_16_Tensor = paddle.empty_like(ndim_11_Tensor)                  # 0
print(ndim_11_Tensor)
print(ndim_12_Tensor)
print(ndim_13_Tensor)
print(ndim_14_Tensor)
print(ndim_15_Tensor)
print(ndim_16_Tensor)
 
# 克隆
ndim_17_Tensor = paddle.clone(ndim_15_Tensor)
print(ndim_17_Tensor)
 
# 符合均匀分布的范围为[0, 1)的随机 Tensor
ndim_18_Tensor = paddle.rand(shape=[2, 3])
# 符合标准正态分布的随机 Tensor
ndim_19_Tensor = paddle.randn(shape=[2, 3])
# 服从均匀分布的、范围在[low, high)的随机 Tensor
ndim_20_Tensor = paddle.randint(low=-5, high=5, shape=[4, 4], dtype='int32')
# 1 维随机
ndim_21_Tensor = paddle.randperm(50, dtype="float", name=None)
# 设置全局随机种子（TODO：没搞明白）
gen = paddle.seed(10000)
ndim_22_Tensor = paddle.rand(shape=[2, 3])
print(ndim_18_Tensor)
print(ndim_19_Tensor)
print(ndim_20_Tensor)
print(ndim_21_Tensor)
print(ndim_22_Tensor)
 
# 指定图像数据创建
fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8)) # 创建随机图片
transform = T.ToTensor()
ndim_23_Tensor = transform(fake_img) # 使用 ToTensor()将图片转换为 Tensor
print(ndim_23_Tensor)
 
# 指定文本数据创建（TODO：没搞明白）
 
#  paddle.io.DataLoader 能够基于原始 Dataset，返回读取 Dataset 数据的迭代器，迭代器返回的数据中的每个元素都是一个 Tensor
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]) # 打印原始数据集的第一个数据的 label
loader = paddle.io.DataLoader(test_dataset)
for data in enumerate(loader):
    x, label = data[1]
    print(label) # 打印由 DataLoader 返回的迭代器中的第一个数据的 label
    break
 
## Tensor 的属性
# 形状（shape）：Tensor 的形状是一个元组，表示每个维度的长度。例如，一个形状为 (3, 4, 5) 的 Tensor 有三个维度，分别是长度为 3、4 和 5。
# 数据类型（dtype）：Tensor 的数据类型指定了存储在 Tensor 中的元素的类型。常见的数据类型包括 float32、float64、int32、int64 等。
# 设备（place）：Tensor 可以存储在不同的设备上，例如 CPU、GPU 或者是 Ascend。Place 指定了 Tensor 所在的设备。
# 梯度（gradient）：在深度学习中，Tensor 的梯度指的是它对某个变量的导数。在反向传播算法中，梯度被用于计算模型参数的更新。
# 名称（name）：Tensor 可以有一个可选的名称，用于在代码中引用 Tensor。
# 数据（data）：Tensor 中存储的实际数值，可以通过 Tensor.numpy() 方法将 Tensor 转换成 numpy 数组进行查看。
# 广播（broadcasting）：Tensor 支持广播操作，即自动扩展维度，使得两个形状不同的 Tensor 可以进行计算。
# 切片（slicing）：Tensor 支持切片操作，可以通过切片方式访问 Tensor 中的元素。
# reshape：Tensor 支持 reshape 操作，可以改变 Tensor 的形状。
# transpose：Tensor 支持 transpose 操作，可以交换 Tensor 的维度。
# 数学运算：Tensor 支持基本的数学运算，例如加减乘除、矩阵乘法等。
# 归一化（normalize）：Tensor 中的元素可以进行归一化操作，即将元素的值缩放到指定的范围内。
# 随机初始化（random initialization）：Tensor 可以通过指定的随机初始化方式初始化为随机值。
ndim_24_Tensor = paddle.ones(shape=[4, 6, 8])
print("每个元素的数据类型:", ndim_24_Tensor.dtype)
print("维度数量:", ndim_24_Tensor.ndim)
print("元素总数:", ndim_24_Tensor.size)
print("每个维度上元素的数量:", ndim_24_Tensor.shape)
print("0轴上的元素数:", ndim_24_Tensor.shape[0])
print("最后一个轴上的元素数:", ndim_24_Tensor.shape[-1])
 
# 重置维度
# paddle.reshape 可重置 Tensor 的形状
# paddle.squeeze，可实现 Tensor 的降维操作，即把 Tensor 中尺寸为 1 的维度删除。
# paddle.unsqueeze，可实现 Tensor 的升维操作，即向 Tensor 中某个位置插入尺寸为 1 的维度。
# paddle.flatten，将 Tensor 的数据在指定的连续维度上展平。
# paddle.transpose，对 Tensor 的数据进行重排。
# 转成1维
ndim_25_Tensor = paddle.reshape(ndim_24_Tensor, [-1])
print(ndim_25_Tensor)
 
# ensor 的数据类型（dtype）
# bool、float16、float32、float64、uint8、int8、int16、int32、int64、complex64、complex128
ndim_2_Tensor = paddle.to_tensor([[(1+1j), (2+2j)],
                                  [(3+3j), (4+4j)]])
print(ndim_2_Tensor)
# 修改数据类型的方法
float64_Tensor = paddle.cast(ndim_2_Tensor, dtype='float64')
print(float64_Tensor)
 
# 设备位置
cpu_Tensor = paddle.to_tensor(1, place=paddle.CPUPlace())
print(cpu_Tensor.place)
# gpu_Tensor = paddle.to_tensor(1, place=paddle.CUDAPlace(0))
# print(gpu_Tensor.place)
# pin_memory_Tensor = paddle.to_tensor(1, place=paddle.CUDAPinnedPlace())
# print(pin_memory_Tensor.place)
 
# 名称
cpu_Tensor.name = "jerry"
print("Tensor name:", cpu_Tensor.name)
 
# stop_gradient 表示是否停止计算梯度，默认值为 True，表示停止计算梯度，梯度不再回传
eg = paddle.to_tensor(1)
print("Tensor stop_gradient:", eg.stop_gradient)
eg.stop_gradient = False
print("Tensor stop_gradient:", eg.stop_gradient)
 
 
## Tensor 的操作
# 访问 Tensor
ndim_1_Tensor = paddle.to_tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])
print("原始张量:", ndim_1_Tensor.numpy()) # 原始 1 维 Tensor
print("第1个元素:", ndim_1_Tensor[0].numpy()) # 取 Tensor 第一个元素的值？
print("最后1个元素:", ndim_1_Tensor[-1].numpy())
print("所有元素:", ndim_1_Tensor[:].numpy())
print("前3个元素:", ndim_1_Tensor[:3].numpy())
print("第7个到最后一个元素:", ndim_1_Tensor[6:].numpy())
print("第4个到第7个元素:", ndim_1_Tensor[3:6].numpy())
print("间隔3个元素:", ndim_1_Tensor[::3].numpy())
print("颠倒:", ndim_1_Tensor[::-1].numpy())
 
ndim_2_Tensor = paddle.to_tensor([[0, 1, 2, 3],
                                  [4, 5, 6, 7],
                                  [8, 9, 10, 11]])
print("原始张量:", ndim_2_Tensor.numpy())
print("第1行:", ndim_2_Tensor[0].numpy())
print("第1行:", ndim_2_Tensor[0, :].numpy())
print("第1列:", ndim_2_Tensor[:, 0].numpy())
print("最后1列:", ndim_2_Tensor[:, -1].numpy())
print("所有元素:", ndim_2_Tensor[:].numpy())
print("第1行第2列:", ndim_2_Tensor[0, 1].numpy())
 
# 修改 Tensor
x = paddle.to_tensor(np.ones((2, 3)).astype(np.float32))
x[0] = 0                      # x : [[0., 0., 0.], [1., 1., 1.]]
x[0:1] = 2.1                  # x : [[2.09999990, 2.09999990, 2.09999990], [1., 1., 1.]]
x[...] = 3                    # x : [[3., 3., 3.], [3., 3., 3.]]
x[0:1] = np.array([1,2,3])    # x : [[1., 2., 3.], [3., 3., 3.]]
x[1] = paddle.ones([3])       # x : [[1., 2., 3.], [1., 1., 1.]]
 
# 数学运算
x = paddle.to_tensor([[1.1, 2.2], [3.3, 4.4]], dtype="float64")
y = paddle.to_tensor([[5.5, 6.6], [7.7, 8.8]], dtype="float64")
print(paddle.add(x, y), "\n") # 方法一
print(x.add(y), "\n") # 方法二
print(x.abs())                       #逐元素取绝对值
print(x.ceil())                      #逐元素向上取整
print(x.floor())                     #逐元素向下取整
print(x.round())                     #逐元素四舍五入
print(x.exp())                       #逐元素计算自然常数为底的指数
print(x.log())                       #逐元素计算 x 的自然对数
print(x.reciprocal())                #逐元素求倒数
print(x.square())                    #逐元素计算平方
print(x.sqrt())                      #逐元素计算平方根
print(x.sin())                       #逐元素计算正弦
print(x.cos())                       #逐元素计算余弦
print(x.add(y))                      #逐元素相加
print(x.subtract(y))                 #逐元素相减
print(x.multiply(y))                 #逐元素相乘
print(x.divide(y))                   #逐元素相除
print(x.mod(y))                      #逐元素相除并取余
print(x.pow(y))                      #逐元素幂运算
print(x.max())                       #指定维度上元素最大值，默认为全部维度
print(x.min())                       #指定维度上元素最小值，默认为全部维度
print(x.prod())                      #指定维度上元素累乘，默认为全部维度
print(x.sum())                       #指定维度上元素的和，默认为全部维度
 
# 逻辑运算
x.isfinite()                  #判断 Tensor 中元素是否是有限的数字，即不包括 inf 与 nan
x.equal_all(y)                #判断两个 Tensor 的全部元素是否相等，并返回形状为[1]的布尔类 Tensor
x.equal(y)                    #判断两个 Tensor 的每个元素是否相等，并返回形状相同的布尔类 Tensor
x.not_equal(y)                #判断两个 Tensor 的每个元素是否不相等
x.less_than(y)                #判断 Tensor x 的元素是否小于 Tensor y 的对应元素
x.less_equal(y)               #判断 Tensor x 的元素是否小于或等于 Tensor y 的对应元素
x.greater_than(y)             #判断 Tensor x 的元素是否大于 Tensor y 的对应元素
x.greater_equal(y)            #判断 Tensor x 的元素是否大于或等于 Tensor y 的对应元素
x.allclose(y)                 #判断 Tensor x 的全部元素是否与 Tensor y 的全部元素接近，并返回形状为[1]的布尔类 Tensor
a1 = paddle.to_tensor([[1,2,3],[4,5,7]])
a2 = paddle.to_tensor([[1,2,3],[4,5,6]])
print(a1.equal_all(a2))
print(a1.equal(a2))
 
x.logical_and(y)              #对两个布尔类型 Tensor 逐元素进行逻辑与操作
x.logical_or(y)               #对两个布尔类型 Tensor 逐元素进行逻辑或操作
x.logical_xor(y)              #对两个布尔类型 Tensor 逐元素进行逻辑亦或操作
x.logical_not(y)              #对两个布尔类型 Tensor 逐元素进行逻辑非操作