一、数据操作

🕗 发布于 2024-11-07 23:04 人工智能 pycharm python 深度学习 pytorch

数据操作

前言
一、张量是什么？
二、张量的基本类型
三、张量的创建
- 3.1 torch.tensor() 根据指定数据创建张量
- 3.2 torch.Tensor() 根据指定形状创建张量，也可以用来创建指定数据的张量
- 3.3 torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量
四、线性张量和随机张量
- 4.1 torch.arange()、torch.linspace() 创建线性张量
- 4.2 随机种子操作
五、创建 0-1 张量
- 5.1 torch.zeros()、torch.zeros_like() 创建全0张量
- 5.2 torch.ones()、torch.ones_like() 创建全1张量
- 5.3 torch.full()、torch.full_like() 创建全为指定值张量
六、张量里的元素类型转换
- 6.1 data.type(torch.DoubleTensor)
- 6.2 data.double()
七、张量的类型转换
- 7.1 张量转换为Numpy数组
- 7.2 Numpy数组转换为张量
- - 7.2.1 使用 from_numpy
  - 7.2.1 使用 torch.tensor
- 7.3 标量张量和数字转换
八、张量的计算
- 8.1 加减乘除取负号
- 8.2 张量点乘运算
- 8.3 张量矩阵乘法运算
九、张量的运算函数
- 9.1 均值
- 9.2 求和
- 9.3 平方 pow（）
- 9.4 平方根 sqrt（）
- 9.5 指数计算 exp（）
- 9.6 对数计算
十、张量的索引操作
- 10.1 简单行列索引的使用
- 10.2 列表索引的使用
- 10.3 范围索引的使用
- 10.4 布尔索引的使用
- 10.5 多维索引的使用
总结

前言

无论使用那个深度学习框架，我们都要使用到张量（tensor），与我们之前学的 Numpy 的 ndarray 类似。
但深度学习框架又比Numpy的ndarray多一些重要功能： .
- 首先，GPU很好地支持加速计算，而NumPy仅支持CPU计算；
- 其次，张量类支持自动微分。

一、张量是什么？

张量，英文为Tensor，是机器学习的基本构建模块，是以数字方式表示数据的形式。
例如，图像可以表示为形状为 [3, 224, 224] 的张量，这意味着 [colour_channels, height, width] ，因为图像具有 3 颜色通道（红色、绿色、蓝色），高度为 224 像素，宽度为 224 像素。
在张量语言（用于描述张量的语言）中，张量将具有三个维度，一个维度表示 colour_channels 、 height 和 width 。

二、张量的基本类型

# 0维张量：标量(scalar)
scalar = torch.tensor(7)         
print(scalar.ndim)  # 0

# 1维张量：向量(vector)
vector = torch.tensor([7, 7])        
print(vector.ndim)  # 1

# 2维张量：矩阵(matrix)
MATRIX = torch.tensor([[7, 8], 
                       [9, 10]])
print(MATRIX .ndim)  # 2

# 多维张量
TENSOR = torch.tensor([[[1, 2, 3],
                        [3, 6, 9],
                        [2, 4, 5]]])
print(TENSOR .ndim)  # 3

三、张量的创建

3.1 torch.tensor() 根据指定数据创建张量

import torch
import numpy as np

# 1. 创建张量标量
data = torch.tensor(10)
print(data)  # tensor(10)


# 2. numpy 数组, 由于 data 为 float64, 下面代码也使用该类型
data = np.random.randn(2, 3)
data = torch.tensor(data)
print(data)  # tensor([[ 0.1345,  0.1149,  0.2435],
             #         [ 0.8026, -0.6744, -1.0918]], dtype=torch.float64)


# 3. 列表, 下面代码使用默认元素类型 float32
data = [[10., 20., 30.], [40., 50., 60.]]
data = torch.tensor(data)
print(data)   # tensor([[10., 20., 30.],
              #         [40., 50., 60.]])

3.2 torch.Tensor() 根据指定形状创建张量，也可以用来创建指定数据的张量

# 1. 创建2行3列的张量, 默认 dtype 为 float32
# 将创建一个形状为 (2, 3) 的张量，但其中的值将是未定义的（即它们可能包含任意数据，取决于内存的状态）
# 这在某些情况下可能不是你想要的行为，因为它可能导致难以追踪的错误。
data = torch.Tensor(2, 3)
print(data)
>>> tensor([[0.0000e+00, 3.6893e+19, 2.2018e+05],
            [4.6577e-10, 2.4158e-12, 1.1625e+33]])

# 2. 注意: 如果传递列表, 则创建包含指定元素的张量
data = torch.Tensor([10])
print(data)
>>> tensor([10.])

data = torch.Tensor([10, 20])
print(data)
>>> tensor([10., 20.])

3.3 torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量

# 1. 创建2行3列, dtype 为 int32 的张量
data = torch.IntTensor(2, 3)
print(data)
>>> tensor([[ 0, 1610612736, 1213662609],
            [ 805308409,  156041223,  1]], dtype=torch.int32)

# 2. 注意: 如果传递的元素类型不正确, 则会进行类型转换
data = torch.IntTensor([2.5, 3.3])
print(data)
>>> tensor([2, 3], dtype=torch.int32)

# 3. 其他的类型
data = torch.ShortTensor()  # int16
data = torch.LongTensor()   # int64
data = torch.FloatTensor()  # float32
data = torch.DoubleTensor() # float64

四、线性张量和随机张量

4.1 torch.arange()、torch.linspace() 创建线性张量

# 1. # 1.arange[开始, 结束, 步长)
# 左闭右开区间, 不写步长 默认是1
data = torch.arange(0, 10, 2)
print(data)
>>> tensor([0, 2, 4, 6, 8])

# 2. 在指定区间按照元素个数生成 [start, end, steps]
# 2. linspace[开始, 结束, 数量]
# 左闭右闭区间, 数量必须写, 意思是一共在这个区间产生几个数
data = torch.linspace(0, 11, 10)
print(data)
>>> tensor([0.0000, 1.2222, 2.4444, 3.6667, 4.8889, 6.1111, 7.3333, 8.5556, 9.7778, 11.0000])

4.2 随机种子操作

# 1. 设置随机种子
# 1.1 创建随机张量
data = torch.randn(2, 3)  # 创建2行3列张量
print(data)
>>> tensor([[-0.5209, -0.2439, -1.1780],
            [ 0.8133,  1.1442,  0.6790]])
            
# 1.2 查看随机种子
print('查看随机种子为:', torch.random.initial_seed()) # 3893177850043400

# 3.2 设置随机种子
torch.random.manual_seed(100) # 设置随机种子为100, 这样在这个文件中,每次生成的tensor就会一样
data2 = torch.randn(2, 3)
print(data2)
print('设置随机种子后:', torch.random.initial_seed()) # 100

五、创建 0-1 张量

5.1 torch.zeros()、torch.zeros_like() 创建全0张量

import torch
import numpy as np

# 1 创建全是 0 的张量
# 1.1 创建1维全是 0 的张量, 一共五个
print(torch.zeros(5))  # tensor([0., 0., 0., 0., 0.])
# 1.2 创建指定形状的全是 0 的张量
data = torch.zeros(2, 3)
print(data)    # tensor([[0., 0., 0.],
               #         [0., 0., 0.]])

# 1.3 根据张量形状创建全是0 的张量
data1 = torch.zeros_like(data)
print(data1)   # tensor([[0., 0., 0.],
               #         [0., 0., 0.]])

5.2 torch.ones()、torch.ones_like() 创建全1张量

# 2 创建全是 1 的张量
# 2.1 创建1维全是 1 的张量, 一共五个
print(torch.ones(5))    # tensor([1., 1., 1., 1., 1.])
# 2.2 创建指定形状的全是 1 的张量
data = torch.ones(2, 3) 
print(data)        # tensor([[1., 1., 1.],
                   #         [1., 1., 1.]])

# 1.3 根据张量形状创建全是 1 的张量
data1 = torch.ones_like(data)
print(data1)     # tensor([[1., 1., 1.],
                 #         [1., 1., 1.]])

5.3 torch.full()、torch.full_like() 创建全为指定值张量

# 3 创建 指定值 的张量
# 3.1 创建指定形状的全是 10 的张量, 传的是 整型 或者 浮点型 的数据, 张量就是什么类型
data = torch.full([3, 2], 10.)
print(data)     # tensor([[10., 10.],
                #         [10., 10.],
                #         [10., 10.]])
                
# 3.2 根据张量形状创建全是 20 的张量, 传进来的数据是什么类型,那么新的张量就是什么类型
data1 = torch.full_like(data, 20)
print(data1)   # tensor([[20., 20.],
               #         [20., 20.],
               #         [20., 20.]])

六、张量里的元素类型转换

6.1 data.type(torch.DoubleTensor)

data = torch.full([2, 3], 10)
print(data.dtype)
>>> torch.int64

# 将 data 元素类型转换为 float64 类型
data = data.type(torch.DoubleTensor)
print(data.dtype)
>>> torch.float64

# 转换为其他类型
# data = data.type(torch.ShortTensor)   # int16
# data = data.type(torch.IntTensor)    # int32
# data = data.type(torch.LongTensor)   # int64
# data = data.type(torch.FloatTensor)  # float32

6.2 data.double()

data = torch.full([2, 3], 10)
print(data.dtype)
>>> torch.int64

# 将 data 元素类型转换为 float64 类型
data = data.double()
print(data.dtype)
>>> torch.float64

# 转换为其他类型
# data = data.short()
# data = data.int()
# data = data.long()
# data = data.float()

七、张量的类型转换

7.1 张量转换为Numpy数组

使用 Tensor.numpy 函数可以将张量转换为 ndarray 数组，但是共享内存，可以使用 copy 函数避免共享。

# 1. 将张量转换为 numpy 数组
data_tensor = torch.tensor([2, 3, 4])
# 使用张量对象中的 numpy 函数进行转换
data_numpy = data_tensor.numpy()
print(type(data_tensor))
>>> <class 'torch.Tensor'>

print(type(data_numpy))
>>> <class 'numpy.ndarray'>

# 注意: data_tensor 和 data_numpy 共享内存
# 修改其中的一个，另外一个也会发生改变
# data_tensor[0] = 100
data_numpy[0] = 100
print(data_tensor)
>>> tensor([100,   3,   4])

print(data_numpy)
>>> [100   3   4]

# 2. 对象拷贝避免共享内存
data_tensor = torch.tensor([2, 3, 4])
# 使用张量对象中的 numpy 函数进行转换，通过copy方法拷贝对象
data_numpy = data_tensor.numpy().copy()
print(type(data_tensor))
>>> <class 'torch.Tensor'>

print(type(data_numpy))
>>> <class 'numpy.ndarray'>

# 注意: data_tensor 和 data_numpy 此时不共享内存
# 修改其中的一个，另外一个不会发生改变
# data_tensor[0] = 100
data_numpy[0] = 100
print(data_tensor)
>>> tensor([2, 3, 4])

print(data_numpy)
>>> [100   3   4]

7.2 Numpy数组转换为张量

7.2.1 使用 from_numpy

使用 from_numpy 可以将 ndarray 数组转换为 Tensor，默认共享内存，使用 copy 函数避免共享

data_numpy = np.array([2, 3, 4])
# 将 numpy 数组转换为张量类型
# 1. from_numpy
# 2. torch.tensor(ndarray)
data_tensor = torch.from_numpy(data_numpy)
# nunpy 和 tensor 共享内存
# data_numpy[0] = 100
data_tensor[0] = 100
print(data_tensor)
>>> tensor([100,   3,   4], dtype=torch.int32)

print(data_numpy)
>>> [100   3   4]

7.2.1 使用 torch.tensor

使用 torch.tensor 可以将 ndarray 数组转换为 Tensor，默认不共享内存

data_numpy = np.array([2, 3, 4])
data_tensor = torch.tensor(data_numpy)
# nunpy 和 tensor 不共享内存
# data_numpy[0] = 100
data_tensor[0] = 100
print(data_tensor)
>>> tensor([100,   3,   4], dtype=torch.int32)

print(data_numpy)
>>> [2 3 4]

7.3 标量张量和数字转换

对于只有一个元素的张量，使用item()函数将该值从张量中提取出来

# 当张量只包含一个元素时, 可以通过 item() 函数提取出该值
data = torch.tensor([30,])
print(data.item())
>>> 30

data = torch.tensor(30)
print(data.item())
>>> 30

八、张量的计算

8.1 加减乘除取负号

add、sub、mul、div、neg
add_、sub_、mul_、div_、neg_（其中带下划线的版本会修改原数据）

data = torch.randint(0, 10, [2, 3])
print(data)
>>> tensor([[3, 7, 4],
            [0, 0, 6]])

# 1. 不修改原数据
new_data = data.add(10)  # 等价 new_data = data + 10
print(new_data)
>>> tensor([[13, 17, 14],
            [10, 10, 16]])

# 2. 直接修改原数据 注意: 带下划线的函数为修改原数据本身
data.add_(10)  # 等价 data += 10
print(data)
>>> tensor([[13, 17, 14],
            [10, 10, 16]])

# 3. 其他函数
print(data.sub(100))
>>> tensor([[-87, -83, -86],
            [-90, -90, -84]])

print(data.mul(100))
>>> tensor([[1300, 1700, 1400],
            [1000, 1000, 1600]])

print(data.div(100))
>>> tensor([[0.1300, 0.1700, 0.1400],
            [0.1000, 0.1000, 0.1600]])

print(data.neg())
>>> tensor([[-13, -17, -14],
            [-10, -10, -16]])

8.2 张量点乘运算

点乘指（Hadamard）的是两个同维矩阵对应位置的元素相乘，使用mul 和运算符 * 实现

data1 = torch.tensor([[1, 2], [3, 4]])
>>> tensor([[1, 2],
            [3, 4]])

data2 = torch.tensor([[5, 6], [7, 8]])
>>> tensor([[5, 6],
            [7, 8]])
            
# 第一种方式
data = torch.mul(data1, data2)
print(data)
>>> tensor([[ 5, 12],
            [21, 32]])

# 第二种方式
data = data1 * data2
print(data)
>>> tensor([[ 5, 12],
            [21, 32]])

8.3 张量矩阵乘法运算

矩阵乘法运算要求第一个矩阵 shape: (n, m)，第二个矩阵 shape: (m, p), 两个矩阵点积运算 shape 为: (n, p)。
运算符 @ 用于进行两个矩阵的乘积运算
torch.matmul 对进行乘积运算的两矩阵形状没有限定.对数输入的 shape 不同的张量, 对应的最后几个维度必须符合矩阵运算规则

# 点积运算
data1 = torch.tensor([[1, 2], [3, 4], [5, 6]])
>>> data1--> tensor([[1, 2],
                     [3, 4],
                     [5, 6]])
                     
data2 = torch.tensor([[5, 6], [7, 8]])
>>> data2--> tensor([[5, 6],
                     [7, 8]])

# 方式一:
data3 = data1 @ data2
print("data3-->", data3)
>>> data3--> tensor([[19, 22],
                     [43, 50],
                     [67, 78]])

# 方式二:
data4 = torch.matmul(data1, data2)
print("data4-->", data4)
>>> data4--> tensor([[19, 22],
                     [43, 50],
                     [67, 78]])

九、张量的运算函数

9.1 均值

import torch

data = torch.randint(0, 10, [2, 3], dtype=torch.float64)
print(data)
>>> tensor([[4., 0., 7.],
            [6., 3., 5.]], dtype=torch.float64)

# 1. 计算均值
# 注意: tensor 必须为 Float 或者 Double 类型
print(data.mean())
>>> tensor(4.1667, dtype=torch.float64)

print(data.mean(dim=0))  # 按列计算均值
>>> tensor([5.0000, 1.5000, 6.0000], dtype=torch.float64)

print(data.mean(dim=1))  # 按行计算均值
>>> tensor([3.6667, 4.6667], dtype=torch.float64)

9.2 求和

# 2. 计算总和
print(data.sum())
>>> tensor(25., dtype=torch.float64)

print(data.sum(dim=0))   # 对列求和
>>> tensor([10.,  3., 12.], dtype=torch.float64)

print(data.sum(dim=1))   # 对行求和
>>> tensor([11., 14.], dtype=torch.float64)

9.3 平方 pow（）

print(torch.pow(data，2))
>>> tensor([[16.,  0., 49.],
            [36.,  9., 25.]], dtype=torch.float64)

9.4 平方根 sqrt（）

print(data.sqrt())
>>> tensor([[2.0000, 0.0000, 2.6458],
            [2.4495, 1.7321, 2.2361]], dtype=torch.float64)

9.5 指数计算 exp（）

print(data.exp())
>>> tensor([[5.4598e+01, 1.0000e+00, 1.0966e+03],
            [4.0343e+02, 2.0086e+01, 1.4841e+02]], dtype=torch.float64)

9.6 对数计算

print(data.log())  # 以 e 为底
>>> tensor([[1.3863,   -inf, 1.9459],
            [1.7918, 1.0986, 1.6094]], dtype=torch.float64)

print(data.log2())
>>> tensor([[2.0000,   -inf, 2.8074],
            [2.5850, 1.5850, 2.3219]], dtype=torch.float64)

print(data.log10())
>>> tensor([[0.6021,   -inf, 0.8451],
            [0.7782, 0.4771, 0.6990]], dtype=torch.float64)

十、张量的索引操作

# 准备数据
import torch
# 随机生成数据
data = torch.randint(0, 10, [4, 5])
print(data)
>>> tensor([[0, 7, 6, 5, 9],
            [6, 8, 3, 1, 0],
            [6, 3, 8, 7, 3],
            [4, 9, 5, 3, 1]])

10.1 简单行列索引的使用

print(data[0])  # 取第一行的数据
>>> tensor([0, 7, 6, 5, 9])

print(data[:, 0])  # 所有的行都要， 取 0 列的数据
>>> tensor([0, 6, 6, 4])

10.2 列表索引的使用

# 返回 (0, 2)、(1, 3) 两个位置的元素
print(data[[0, 1], [2, 3]])
>>> tensor([6, 1])

# 返回 0、1 行的 1、2 列共4个元素
print(data[[[0], [1]], [1, 2]])
>>> tensor([[7, 6],
            [8, 3]])

10.3 范围索引的使用

# 前3行的前2列数据
print(data[:3, :2])
>>> tensor([[0, 7],
            [6, 8],
            [6, 3]])

# 第2行到最后的前2列数据
print(data[2:, :2])
>>> tensor([[6, 3],
            [4, 9]])

# 第0行、第2行的第0、1两列数据
print(data[0:3:2, :2])
>>>tensor([[0, 7],
            [6, 3]])

10.4 布尔索引的使用

# 第三列大于5的行数据
print(data[data[:, 2] > 5])
>>> tensor([[0, 7, 6, 5, 9],
            [6, 3, 8, 7, 3]])

# 第二行大于5的列数据
print(data[:, data[1] > 5])  3 
>>> tensor([[0, 7],
            [6, 8],
            [6, 3],
            [4, 9]])

10.5 多维索引的使用

data = torch.randint(0, 10, [3, 4, 5])
print(data)
>>> tensor([[[2, 4, 1, 2, 3],
             [5, 5, 1, 5, 0],
             [1, 4, 5, 3, 8],
             [7, 1, 1, 9, 9]],

            [[9, 7, 5, 3, 1],
             [8, 8, 6, 0, 1],
             [6, 9, 0, 2, 1],
             [9, 7, 0, 4, 0]],

            [[0, 7, 3, 5, 6],
             [2, 4, 6, 4, 3],
             [2, 0, 3, 7, 9],
             [9, 6, 4, 4, 4]]])

# 获取0轴上的第一个数据
print(data[0, :, :])
>>> tensor([[2, 4, 1, 2, 3],
            [5, 5, 1, 5, 0],
            [1, 4, 5, 3, 8],
            [7, 1, 1, 9, 9]])

# 获取1轴上的第一个数据
print(data[:, 0, :])
>>> tensor([[2, 4, 1, 2, 3],
            [9, 7, 5, 3, 1],
            [0, 7, 3, 5, 6]])

# 获取2轴上的第一个数据
print(data[:, :, 0])
>>> tensor([[2, 5, 1, 7],
            [9, 8, 6, 9],
            [0, 2, 2, 9]])

总结

深度学习存储和操作数据的主要接口是张量（n维数组）。它提供了各种功能，包括基本数学运算、广播、索引、切片、内存节省和转换其他Python对象。
所以张量是学习深度学习的基础。

原文地址：https://blog.csdn.net/Lyg970112/article/details/143605578

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【RabbitMQ】之高可用集群搭建
下一篇：day20：三剑客——awk基础

Rust性能优化与调试之性能基准测试
在 Criterion 中创建多个测试组，通过分组功能生成针对不同环境（例如小规模数据 vs 大规模数据、冷缓存 vs 热缓存）的详细分析报告，帮助开发者在不同场景下优化性能。为保证测试结果的实用性，
阅读更多2024-11-08
ABC377
我们手动来看例子：5,6,3,1,2,4 -> 2,4,3,5,6,1 -> 4,5,3,6,1,2 -> 6,1,3,2,4,5。按顺序插入，插入的时候去看每个位置到之前的叶子节
阅读更多2024-11-08
Linux文本操作三大利器总结：sed、awk、grep
Linux文本操作三大利器总结：sed、awk、grep
阅读更多2024-11-08
第三章：TDengine 常用操作和高级功能
TDengine 是一个专门为物联网（IoT）和大数据场景设计的高性能时序数据库。除了基本的创建数据库、表、插入和查询数据之外，TDengine 还提供了许多其他常用操作和高级功能。
阅读更多2024-11-08
50岁+人群月活超1亿，短剧迎来新对手，小程序游戏“收割”中老年
年轻人玩的游戏太复杂了，基本的下载都很麻烦，小程序游戏操作方便，随时点开就可以在上面下象棋、打麻将，方便多了，”现年55岁的小刘叔叔告诉AgeTravel。过去受到中老年玩家欢迎的游戏产品，往往都具备
阅读更多2024-11-08
在 Bash 中获取 Python 模块变量列
在 Bash 中获取 Python 模块的变量列表可以通过使用 python -c 来运行 Python 代码并输出变量名列表。
阅读更多2024-11-08
斗破QT编程入门系列之二：认识Qt：编写一个HelloWorld程序（四星斗师）
窗口左侧有上下两个子窗口，上方的目录树显示了项目内文件的组织结构，显示当前项目的名称，项目的名称都成目录树的一个跟节点，Qt Creator可以打开多个项目，但是只有一个活动项目（Active Pro
阅读更多2024-11-08
Bash Shell - 获取日期、时间
以下代码将date的执行结果存储在today变量中。date 是获取日期和时间的命令。可以获取几周前/几周后或几个月前/之后的时间。选择使用 quotes(`)或$使用date获取日期。
阅读更多2024-11-08
深入理解 Linux 内存管理：free 命令详解
Linux 系统中 free 命令的使用及其输出各个字段的含义，理解物理内存和交换分区的使用情况，计算内存使用率，free 命令的其他重要选项及其组合使用方法，交换分区的作用、清除方法及其对性能的影响
阅读更多2024-11-08
GPU 服务器：超酷算力担当→科技界的宝藏神器！
这 GPU 服务器的厉害之处，很大程度上就靠它那超强的算力。电影制作的时候，GPU 服务器能快速搞特效处理，像《阿凡达》里的虚拟场景和特效制作，没 GPU 算力可不行。#GPU 服务器#高性能计算#图
阅读更多2024-11-08

一、数据操作

数据操作

前言

一、张量是什么？

二、张量的基本类型

三、张量的创建

3.1 torch.tensor() 根据指定数据创建张量

3.2 torch.Tensor() 根据指定形状创建张量，也可以用来创建指定数据的张量

3.3 torch.IntTensor()、torch.FloatTensor()、torch.DoubleTensor() 创建指定类型的张量

四、线性张量和随机张量

4.1 torch.arange()、torch.linspace() 创建线性张量

4.2 随机种子操作

五、创建 0-1 张量

5.1 torch.zeros()、torch.zeros_like() 创建全0张量

5.2 torch.ones()、torch.ones_like() 创建全1张量

5.3 torch.full()、torch.full_like() 创建全为指定值张量

六、张量里的元素类型转换

6.1 data.type(torch.DoubleTensor)

6.2 data.double()

七、张量的类型转换

7.1 张量转换为Numpy数组

7.2 Numpy数组转换为张量

7.2.1 使用 from_numpy

7.2.1 使用 torch.tensor

7.3 标量张量和数字转换

八、张量的计算

8.1 加减乘除取负号

8.2 张量点乘运算

8.3 张量矩阵乘法运算

九、张量的运算函数

9.1 均值

9.2 求和

9.3 平方 pow（）

9.4 平方根 sqrt（）

9.5 指数计算 exp（）

9.6 对数计算

十、张量的索引操作

10.1 简单行列索引的使用

10.2 列表索引的使用

10.3 范围索引的使用

10.4 布尔索引的使用

10.5 多维索引的使用

总结

相关文章