目录

前言

一、张量、算子是什么？

二、使用pytorch实现张量运算

1.2 张量

1.2.1 创建张量

1.2.2 张量的属性 

1.2.4 张量的访问 

1.2.5 张量的运算

三. 数据预处理

总结

前言

本文主要是对张量和算子进行简单的解释，以及使用pytorch实现张量运算和数据的预处理。

一、张量、算子是什么？

张量：在我理解来说，张量是一种数据类型，其实就是多维的数组。简单点来讲，拿一个小区如果把一个数装进一个房间里，那这个“房间”就是最简单一维张量，而二维张量就相当于一层楼中所有房间的集合，则三维张量就相当于一栋楼中所有房间的集合，四位张量就相当于一个小区中所有房间的集合......。如此类推，用图像来说明

算子：大家在理解算子之前建议大家先去看看映射的相关概念。简单的来说你可以粗略的认为算子是一种运算，对任何函数进行某一项操作都可以认为是一个算子，甚至包括求幂次，开方都可以认为是一个算子，总而言之，无论一个函数映射成另一个函数，或者一个函数映射成一个数，这个过程都可看做是算子。算子就是映射，就是关系，就是变换。

二、使用pytorch实现张量运算

1.2 张量

1.2.1 创建张量

1.2.1.1 指定数据创建张量

import torch
p = torch.tensor([[1,1,1,1],[2,2,2,2],[3,3,3,3]])
print(p)

tensor([[1, 1, 1, 1],
        [2, 2, 2, 2],
        [3, 3, 3, 3]]) 

1.2.1.2 指定形状创建

m, n = 2, 3
# 使用torch.zeros创建数据全为0，形状为[m, n]的Tensor
zeros = torch.zeros([m, n])
# 使用torch.ones创建数据全为1，形状为[m, n]的Tensor
ones = torch.ones([m, n])
# 使用torch.full创建数据全为指定值，形状为[m, n]的Tensor，这里我们指定数据为10
full = torch.full([m, n], 10)
print('zeros : ', zeros)
print('ones : ', ones)
print('full : ', full)

zeros :  tensor([[0., 0., 0.],
        [0., 0., 0.]])
ones :  tensor([[1., 1., 1.],
        [1., 1., 1.]])
full :  tensor([[10, 10, 10],
        [10, 10, 10]]) 

 1.2.1.3 指定区间创建

# 使用torch.arange创建以步长step均匀分隔数值区间[start, end)的一维Tensor
arange = torch.arange(start=1, end=5, step=1)
# 使用torch.linspace创建以元素个数steps均匀分隔数值区间[start, end]的Tensor
linspace = torch.linspace(start=1, end=5, steps=5)
print('arange: ', arange)
print('linspace: ', linspace)

arange:  tensor([1, 2, 3, 4])
linspace:  tensor([1., 2., 3., 4., 5.]) 

1.2.2 张量的属性 

1.2.2.1 张量的形状

ndim_4_Tensor = torch.ones([2, 3, 4, 5])
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])
print('Number of elements in Tensor: ', ndim_4_Tensor.numel())

 Number of dimensions: 4
Shape of Tensor: torch.Size([2, 3, 4, 5])
Elements number along axis 0 of Tensor: 2
Elements number along the last axis of Tensor: 5
Number of elements in Tensor:  120 

1.2.2.2 形状的改变

# 定义一个shape为[3,2,5]的三维Tensor
ndim_3_Tensor = torch.tensor([[[1, 2, 3, 4, 5],
                                   [6, 7, 8, 9, 10]],
                                  [[11, 12, 13, 14, 15],
                                   [16, 17, 18, 19, 20]],
                                  [[21, 22, 23, 24, 25],
                                   [26, 27, 28, 29, 30]]])
print("the shape of ndim_3_Tensor:", ndim_3_Tensor.shape)
# torch.reshape 可以保持在输入数据不变的情况下，改变数据形状。这里我们设置reshape为[2,5,3]
reshape_Tensor = torch.reshape(ndim_3_Tensor, [2, 5, 3])
print("After reshape:", reshape_Tensor)

the shape of ndim_3_Tensor: torch.Size([3, 2, 5])
After reshape: tensor([[[ 1,  2,  3],
         [ 4,  5,  6],
         [ 7,  8,  9],
         [10, 11, 12],
         [13, 14, 15]],

        [[16, 17, 18],
         [19, 20, 21],
         [22, 23, 24],
         [25, 26, 27],
         [28, 29, 30]]])

1.2.2.3 张量的数据类型

# 使用torch.tensor通过已知数据来创建一个Tensor
print("Tensor dtype from Python integers:", torch.tensor(1).dtype)
print("Tensor dtype from Python floating point:", torch.tensor(1.0).dtype)

Tensor dtype from Python integers: torch.int64
Tensor dtype from Python floating point: torch.float32

1.2.2.4 张量的设备位置

cpu_Tensor = torch.tensor(1)
# 通过Tensor.place查看张量所在设备位置
print('cpu Tensor: ', cpu_Tensor.device)
# 创建GPU上的Tensor
gpu_Tensor = torch.tensor(1, device='cuda:0') #可以用to方法来回转化
print('gpu Tensor: ', gpu_Tensor.device)
pin_memory_Tensor = torch.tensor(1,pin_memory=True)
print('pin memory Tensor: ', pin_memory_Tensor.device)

AssertionError: Torch not compiled with CUDA enabled 

 在创建GPU上的Tensor时，系统报错，在网上查询一番后发现最后发现问题出现在Pytorch和CUDA版本不兼容的问题上。问题的发现可以在终端中输入'python'命令，运行python后，输入

import torch
print(torch.__version__)
print(torch.cuda.is_available())

如果输出的结果是False，那么说明当前的Pytorch版本无法使用显卡。

 然后在检查自己的GPU版本后，在根据自己的CUDA版本在Pytorch官网查看并安装可用的版本后解决了这个问题。

cpu Tensor:  cpu

gpu Tensor:  cuda:0
pin memory Tensor:  cpu

1.2.3 张量与Numpy数组转换

张量和Numpy数组可以相互转换。第1.2.2.3节中我们了解到paddle.to_tensor()函数可以将Numpy数组转化为张量，也可以通过Tensor.numpy()函数将张量转化为Numpy数组。

ndim_1_Tensor = torch.tensor([1., 2.])
# 将当前 Tensor 转化为 numpy.ndarray
print('Tensor to convert: ', ndim_1_Tensor.numpy())

 Tensor to convert:  [1. 2.]

1.2.4 张量的访问 

1.2.4.1 索引和切片

import torch
# 定义1个一维Tensor
ndim_1_Tensor = torch.tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])
print("Origin Tensor:", ndim_1_Tensor)
print("First element:", ndim_1_Tensor[0])
print("Last element:", ndim_1_Tensor[-1])
print("All element:", ndim_1_Tensor[:])
print("Before 3:", ndim_1_Tensor[:3])
print("Interval of 3:", ndim_1_Tensor[::3])

 Origin Tensor: tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])
First element: tensor(0)
Last element: tensor(8)
All element: tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])
Before 3: tensor([0, 1, 2])
Interval of 3: tensor([0, 3, 6])

1.2.4.2 访问张量

针对一维张量，对单个轴进行索引和切片。

import torch
# 定义1个二维Tensor
ndim_2_Tensor = torch.tensor([[0, 1, 2, 3],
                                  [4, 5, 6, 7],
                                  [8, 9, 10, 11]])
print("Origin Tensor:", ndim_2_Tensor)
print("First row:", ndim_2_Tensor[0])
print("First row:", ndim_2_Tensor[0, :])
print("First column:", ndim_2_Tensor[:, 0])
print("Last column:", ndim_2_Tensor[:, -1])
print("All element:", ndim_2_Tensor[:])
print("First row and second column:", ndim_2_Tensor[0, 1])

Origin Tensor: tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
First row: tensor([0, 1, 2, 3])
First row: tensor([0, 1, 2, 3])
First column: tensor([0, 4, 8])
Last column: tensor([ 3,  7, 11])
All element: tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
First row and second column: tensor(1)

1.2.4.3 修改张量

与访问张量类似，可以在单个或多个轴上通过索引或切片操作来修改张量。

提醒
慎重通过索引或切片操作来修改张量，此操作仅会原地修改该张量的数值，且原值不会被保存。如果被修改的张量参与梯度计算，将仅会使用修改后的数值，这可能会给梯度计算引入风险。

# 定义1个二维Tensor
ndim_2_Tensor = torch.ones([2, 3], dtype=torch.float32)
print('Origin Tensor: ', ndim_2_Tensor)
# 修改第1维为0
ndim_2_Tensor[0] = 0
print('change Tensor: ', ndim_2_Tensor)
# 修改第1维为2.1
ndim_2_Tensor[0:1] = 2.1
print('change Tensor: ', ndim_2_Tensor)
# 修改全部Tensor
ndim_2_Tensor[...] = 3
print('change Tensor: ', ndim_2_Tensor)

Origin Tensor:  tensor([[1., 1., 1.],
        [1., 1., 1.]])
change Tensor:  tensor([[0., 0., 0.],
        [1., 1., 1.]])
change Tensor:  tensor([[2.1000, 2.1000, 2.1000],
        [1.0000, 1.0000, 1.0000]])
change Tensor:  tensor([[3., 3., 3.],
        [3., 3., 3.]])
 

1.2.5 张量的运算

1.2.5.1 数学运算

张量支持包括基础数学运算、逻辑运算、矩阵运算等100余种运算操作，以加法为例，有如下两种实现方式：
1）使用torch.add(x,y)。
2）使用张量类成员函数x.add(y)。

# 定义两个Tensor
x = torch.tensor([[1.1, 2.2], [3.3, 4.4]], dtype=torch.float64)
y = torch.tensor([[5.5, 6.6], [7.7, 8.8]], dtype=torch.float64)
# 第一种调用方法，torch.add逐元素相加算子，并将各个位置的输出元素保存到返回结果中
print('Method 1: ', torch.add(x, y))
# 第二种调用方法
print('Method 2: ', x.add(y))

Method 1:  tensor([[ 6.6000,  8.8000],
        [11.0000, 13.2000]], dtype=torch.float64)
Method 2:  tensor([[ 6.6000,  8.8000],
        [11.0000, 13.2000]], dtype=torch.float64)

此外还有以下算法

x.abs()                       # 逐元素取绝对值
x.ceil()                      # 逐元素向上取整
x.floor()                     # 逐元素向下取整
x.round()                     # 逐元素四舍五入
x.exp()                       # 逐元素计算自然常数为底的指数
x.log()                       # 逐元素计算x的自然对数
x.reciprocal()                # 逐元素求倒数
x.square()                    # 逐元素计算平方
x.sqrt()                      # 逐元素计算平方根
x.sin()                       # 逐元素计算正弦
x.cos()                       # 逐元素计算余弦
x.add(y)                      # 逐元素加
x.subtract(y)                 # 逐元素减
x.multiply(y)                 # 逐元素乘（积）
x.divide(y)                   # 逐元素除
x.mod(y)                      # 逐元素除并取余
x.pow(y)                      # 逐元素幂
x.max()                       # 指定维度上元素最大值，默认为全部维度
x.min()                       # 指定维度上元素最小值，默认为全部维度
x.prod()                      # 指定维度上元素累乘，默认为全部维度
x.sum()                       # 指定维度上元素的和，默认为全部维度

笔记
由于张量类成员函数操作更为方便，以下均从张量类成员函数的角度，对常用张量操作进行介绍。

1.2.5.2 逻辑运算

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的全部元素是否接近

1.2.5.3 矩阵运算

x.t()                         # 矩阵转置
x.transpose([1, 0])           # 交换第 0 维与第 1 维的顺序
x.norm('fro')                 # 矩阵的弗罗贝尼乌斯范数
x.dist(y, p=2)                # 矩阵（x-y）的2范数
x.matmul(y)                   # 矩阵乘法

有些矩阵运算中也支持大于两维的张量，比如matmul函数，对最后两个维度进行矩阵乘。比如x是形状为[j,k,n,m]的张量，另一个y是[j,k,m,p]的张量，则x.matmul(y)输出的张量形状为[j,k,n,p]。

1.2.5.4 广播机制

torch支持广播(Broadcasting)机制，允许在一些运算时使用不同形状的张量。通常来讲，如果有一个形状较小和一个形状较大的张量，会希望多次使用较小的张量来对较大的张量执行某些操作，看起来像是形状较小的张量首先被扩展到和较大的张量形状一致，然后再做运算。.

广播机制的条件

广播机制主要遵循如下规则（参考Numpy广播机制）：

1）每个张量至少为一维张量。

2）从后往前比较张量的形状，当前维度的大小要么相等，要么其中一个等于1，要么其中一个不存在。

# 当两个Tensor的形状一致时，可以广播
x = torch.ones((2, 3, 4))
y = torch.ones((2, 3, 4))
z = x + y
print('broadcasting with two same shape tensor: ', z.shape)

x = torch.ones((2, 3, 1, 5))
y = torch.ones((3, 4, 1))
# 从后往前依次比较：
# 第一次：y的维度大小是1
# 第二次：x的维度大小是1
# 第三次：x和y的维度大小相等，都为3
# 第四次：y的维度不存在
# 所以x和y是可以广播的
z = x + y
print('broadcasting with two different shape tensor:', z.shape)

broadcasting with two same shape tensor:  torch.Size([2, 3, 4])
broadcasting with two different shape tensor: torch.Size([2, 3, 4, 5])

• 从输出结果看，x与y在上述两种情况中均遵循广播规则，因此在张量相加时可以广播。我们再定义两个shape分别为[2, 3, 4]和[2, 3, 6]的张量，观察这两个张量是否能够通过广播操作相加。

import torch
x = torch.ones((2, 3, 4))
y = torch.ones((2, 3, 6))
z = x + y

RuntimeError: The size of tensor a (4) must match the size of tensor b (6) at non-singleton dimension 2 

从输出结果看，此时x和y是不能广播的，因为在第一次从后往前的比较中，4和6不相等，不符合广播规则。

广播机制的计算规则

现在我们知道在什么情况下两个张量是可以广播的。两个张量进行广播后的结果张量的形状计算规则如下：

1）如果两个张量shape的长度不一致，那么需要在较小长度的shape前添加1，直到两个张量的形状长度相等。

2） 保证两个张量形状相等之后，每个维度上的结果维度就是当前维度上较大的那个。

以张量x和y进行广播为例，x的shape为[2, 3, 1，5]，张量y的shape为[3，4，1]。首先张量y的形状长度较小，因此要将该张量形状补齐为[1, 3, 4, 1]，再对两个张量的每一维进行比较。从第一维看，x在一维上的大小为2，y为1，因此，结果张量在第一维的大小为2。以此类推，对每一维进行比较，得到结果张量的形状为[2, 3, 4, 5]。

由于矩阵乘法函数paddle.matmul在深度学习中使用非常多，这里需要特别说明一下它的广播规则：

1）如果两个张量均为一维，则获得点积结果。

2） 如果两个张量都是二维的，则获得矩阵与矩阵的乘积。

3） 如果张量x是一维，y是二维，则将x的shape转换为[1, D]，与y进行矩阵相乘后再删除前置尺寸。

4） 如果张量x是二维，y是一维，则获得矩阵与向量的乘积。

5） 如果两个张量都是N维张量（N > 2），则根据广播规则广播非矩阵维度（除最后两个维度外其余维度）。比如：如果输入x是形状为[j,1,n,m]的张量，另一个y是[k,m,p]的张量，则输出张量的形状为[j,k,n,p]。

x = torch.ones([10, 1, 5, 2])
y = torch.ones([3, 2, 5])
z = torch.matmul(x, y)
print('After matmul: ', z.shape)

After matmul:  torch.Size([10, 3, 5, 5])

 从输出结果看，计算张量乘积时会使用到广播机制。

三. 数据预处理

1. 读取数据集 house_tiny.csv、boston_house_prices.csv、Iris.csv

2. 处理缺失值

3. 转换为张量格式

import pandas as pd
import numpy as np
import torch
#读取数据集
data_iris = pd.read_csv('Iris.csv')
data_house_tiny = pd.read_csv('house_tiny.csv')
data_boston_house_prices = pd.read_csv('boston_house_prices.csv')
#处理缺失值和离散值
input,output = data_iris.iloc[:,0:5],data_iris.iloc[:,5]
#使用均值处理缺失值
input = input.fillna(input.mean())
input = np.array(input)

#处理离散值
output = pd.get_dummies(output,dummy_na=True)
output = np.array(output)
#转换为张量形式
input_tensor,output_tensor = torch.tensor(input),torch.tensor(output)
print(input_tensor,output_tensor)
#读取输入输出
input_house_tiny,output_house_tiny = data_house_tiny.iloc[:,0:2],data_house_tiny.iloc[:,2]
#处理缺失值
input_house_tiny = input_house_tiny.fillna(input_house_tiny.mean())
#处理离散值
input_house_tiny = pd.get_dummies(input_house_tiny,dummy_na=True)
input_house_tiny,output_house_tiny = np.array(input_house_tiny),np.array(output_house_tiny)
#转换为张量形式
input_house_tiny_tensor,output_house_tiny_tensor = torch.tensor(input_house_tiny),torch.tensor(output_house_tiny)
print(input_house_tiny_tensor,output_house_tiny_tensor)


#读取输出
input_boston_house_prices,output_boston_house_prices = data_boston_house_prices.iloc[:,0:12],data_boston_house_prices.iloc[:,12]
#处理缺失值
input_boston_house_prices,output_boston_house_prices = input_boston_house_prices.fillna(input_boston_house_prices.mean()),output_boston_house_prices.fillna(output_boston_house_prices.mean())
#转换为张量形式
input_boston_house_prices_numpy,output_boston_house_prices_numpy = np.array(input_boston_house_prices),np.array(output_boston_house_prices)
input_boston_house_prices_tensor,output_boston_house_prices_tensor = torch.tensor(input_boston_house_prices_numpy),torch.tensor(output_boston_house_prices_numpy)
print(input_boston_house_prices_tensor,output_boston_house_prices_tensor)

tensor([[1.0000e+00, 5.1000e+00, 3.5000e+00, 1.4000e+00, 2.0000e-01],
        [2.0000e+00, 4.9000e+00, 3.0000e+00, 1.4000e+00, 2.0000e-01],
        [3.0000e+00, 4.7000e+00, 3.2000e+00, 1.3000e+00, 2.0000e-01],
        [4.0000e+00, 4.6000e+00, 3.1000e+00, 1.5000e+00, 2.0000e-01],
        [5.0000e+00, 5.0000e+00, 3.6000e+00, 1.4000e+00, 2.0000e-01],
        [6.0000e+00, 5.4000e+00, 3.9000e+00, 1.7000e+00, 4.0000e-01],
        [7.0000e+00, 4.6000e+00, 3.4000e+00, 1.4000e+00, 3.0000e-01],
        [8.0000e+00, 5.0000e+00, 3.4000e+00, 1.5000e+00, 2.0000e-01],
        [9.0000e+00, 4.4000e+00, 2.9000e+00, 1.4000e+00, 2.0000e-01],
        [1.0000e+01, 4.9000e+00, 3.1000e+00, 1.5000e+00, 1.0000e-01],
        [1.1000e+01, 5.4000e+00, 3.7000e+00, 1.5000e+00, 2.0000e-01],
        [1.2000e+01, 4.8000e+00, 3.4000e+00, 1.6000e+00, 2.0000e-01],
        [1.3000e+01, 4.8000e+00, 3.0000e+00, 1.4000e+00, 1.0000e-01],
        [1.4000e+01, 4.3000e+00, 3.0000e+00, 1.1000e+00, 1.0000e-01],
        [1.5000e+01, 5.8000e+00, 4.0000e+00, 1.2000e+00, 2.0000e-01],
        [1.6000e+01, 5.7000e+00, 4.4000e+00, 1.5000e+00, 4.0000e-01],
        [1.7000e+01, 5.4000e+00, 3.9000e+00, 1.3000e+00, 4.0000e-01],
        [1.8000e+01, 5.1000e+00, 3.5000e+00, 1.4000e+00, 3.0000e-01],
        [1.9000e+01, 5.7000e+00, 3.8000e+00, 1.7000e+00, 3.0000e-01],
        [2.0000e+01, 5.1000e+00, 3.8000e+00, 1.5000e+00, 3.0000e-01],
        [2.1000e+01, 5.4000e+00, 3.4000e+00, 1.7000e+00, 2.0000e-01],
        [2.2000e+01, 5.1000e+00, 3.7000e+00, 1.5000e+00, 4.0000e-01],
        [2.3000e+01, 4.6000e+00, 3.6000e+00, 1.0000e+00, 2.0000e-01],
        [2.4000e+01, 5.1000e+00, 3.3000e+00, 1.7000e+00, 5.0000e-01],
        [2.5000e+01, 4.8000e+00, 3.4000e+00, 1.9000e+00, 2.0000e-01],
        [2.6000e+01, 5.0000e+00, 3.0000e+00, 1.6000e+00, 2.0000e-01],
        [2.7000e+01, 5.0000e+00, 3.4000e+00, 1.6000e+00, 4.0000e-01],
        [2.8000e+01, 5.2000e+00, 3.5000e+00, 1.5000e+00, 2.0000e-01],
        [2.9000e+01, 5.2000e+00, 3.4000e+00, 1.4000e+00, 2.0000e-01],
        [3.0000e+01, 4.7000e+00, 3.2000e+00, 1.6000e+00, 2.0000e-01],
        [3.1000e+01, 4.8000e+00, 3.1000e+00, 1.6000e+00, 2.0000e-01],
        [3.2000e+01, 5.4000e+00, 3.4000e+00, 1.5000e+00, 4.0000e-01],
        [3.3000e+01, 5.2000e+00, 4.1000e+00, 1.5000e+00, 1.0000e-01],
        [3.4000e+01, 5.5000e+00, 4.2000e+00, 1.4000e+00, 2.0000e-01],
        [3.5000e+01, 4.9000e+00, 3.1000e+00, 1.5000e+00, 1.0000e-01],
        [3.6000e+01, 5.0000e+00, 3.2000e+00, 1.2000e+00, 2.0000e-01],
        [3.7000e+01, 5.5000e+00, 3.5000e+00, 1.3000e+00, 2.0000e-01],
        [3.8000e+01, 4.9000e+00, 3.1000e+00, 1.5000e+00, 1.0000e-01],
        [3.9000e+01, 4.4000e+00, 3.0000e+00, 1.3000e+00, 2.0000e-01],
        [4.0000e+01, 5.1000e+00, 3.4000e+00, 1.5000e+00, 2.0000e-01],
        [4.1000e+01, 5.0000e+00, 3.5000e+00, 1.3000e+00, 3.0000e-01],
        [4.2000e+01, 4.5000e+00, 2.3000e+00, 1.3000e+00, 3.0000e-01],
        [4.3000e+01, 4.4000e+00, 3.2000e+00, 1.3000e+00, 2.0000e-01],
        [4.4000e+01, 5.0000e+00, 3.5000e+00, 1.6000e+00, 6.0000e-01],
        [4.5000e+01, 5.1000e+00, 3.8000e+00, 1.9000e+00, 4.0000e-01],
        [4.6000e+01, 4.8000e+00, 3.0000e+00, 1.4000e+00, 3.0000e-01],
        [4.7000e+01, 5.1000e+00, 3.8000e+00, 1.6000e+00, 2.0000e-01],
        [4.8000e+01, 4.6000e+00, 3.2000e+00, 1.4000e+00, 2.0000e-01],
        [4.9000e+01, 5.3000e+00, 3.7000e+00, 1.5000e+00, 2.0000e-01],
        [5.0000e+01, 5.0000e+00, 3.3000e+00, 1.4000e+00, 2.0000e-01],
        [5.1000e+01, 7.0000e+00, 3.2000e+00, 4.7000e+00, 1.4000e+00],
        [5.2000e+01, 6.4000e+00, 3.2000e+00, 4.5000e+00, 1.5000e+00],
        [5.3000e+01, 6.9000e+00, 3.1000e+00, 4.9000e+00, 1.5000e+00],
        [5.4000e+01, 5.5000e+00, 2.3000e+00, 4.0000e+00, 1.3000e+00],
        [5.5000e+01, 6.5000e+00, 2.8000e+00, 4.6000e+00, 1.5000e+00],
        [5.6000e+01, 5.7000e+00, 2.8000e+00, 4.5000e+00, 1.3000e+00],
        [5.7000e+01, 6.3000e+00, 3.3000e+00, 4.7000e+00, 1.6000e+00],
        [5.8000e+01, 4.9000e+00, 2.4000e+00, 3.3000e+00, 1.0000e+00],
        [5.9000e+01, 6.6000e+00, 2.9000e+00, 4.6000e+00, 1.3000e+00],
        [6.0000e+01, 5.2000e+00, 2.7000e+00, 3.9000e+00, 1.4000e+00],
        [6.1000e+01, 5.0000e+00, 2.0000e+00, 3.5000e+00, 1.0000e+00],
        [6.2000e+01, 5.9000e+00, 3.0000e+00, 4.2000e+00, 1.5000e+00],
        [6.3000e+01, 6.0000e+00, 2.2000e+00, 4.0000e+00, 1.0000e+00],
        [6.4000e+01, 6.1000e+00, 2.9000e+00, 4.7000e+00, 1.4000e+00],
        [6.5000e+01, 5.6000e+00, 2.9000e+00, 3.6000e+00, 1.3000e+00],
        [6.6000e+01, 6.7000e+00, 3.1000e+00, 4.4000e+00, 1.4000e+00],
        [6.7000e+01, 5.6000e+00, 3.0000e+00, 4.5000e+00, 1.5000e+00],
        [6.8000e+01, 5.8000e+00, 2.7000e+00, 4.1000e+00, 1.0000e+00],
        [6.9000e+01, 6.2000e+00, 2.2000e+00, 4.5000e+00, 1.5000e+00],
        [7.0000e+01, 5.6000e+00, 2.5000e+00, 3.9000e+00, 1.1000e+00],
        [7.1000e+01, 5.9000e+00, 3.2000e+00, 4.8000e+00, 1.8000e+00],
        [7.2000e+01, 6.1000e+00, 2.8000e+00, 4.0000e+00, 1.3000e+00],
        [7.3000e+01, 6.3000e+00, 2.5000e+00, 4.9000e+00, 1.5000e+00],
        [7.4000e+01, 6.1000e+00, 2.8000e+00, 4.7000e+00, 1.2000e+00],
        [7.5000e+01, 6.4000e+00, 2.9000e+00, 4.3000e+00, 1.3000e+00],
        [7.6000e+01, 6.6000e+00, 3.0000e+00, 4.4000e+00, 1.4000e+00],
        [7.7000e+01, 6.8000e+00, 2.8000e+00, 4.8000e+00, 1.4000e+00],
        [7.8000e+01, 6.7000e+00, 3.0000e+00, 5.0000e+00, 1.7000e+00],
        [7.9000e+01, 6.0000e+00, 2.9000e+00, 4.5000e+00, 1.5000e+00],
        [8.0000e+01, 5.7000e+00, 2.6000e+00, 3.5000e+00, 1.0000e+00],
        [8.1000e+01, 5.5000e+00, 2.4000e+00, 3.8000e+00, 1.1000e+00],
        [8.2000e+01, 5.5000e+00, 2.4000e+00, 3.7000e+00, 1.0000e+00],
        [8.3000e+01, 5.8000e+00, 2.7000e+00, 3.9000e+00, 1.2000e+00],
        [8.4000e+01, 6.0000e+00, 2.7000e+00, 5.1000e+00, 1.6000e+00],
        [8.5000e+01, 5.4000e+00, 3.0000e+00, 4.5000e+00, 1.5000e+00],
        [8.6000e+01, 6.0000e+00, 3.4000e+00, 4.5000e+00, 1.6000e+00],
        [8.7000e+01, 6.7000e+00, 3.1000e+00, 4.7000e+00, 1.5000e+00],
        [8.8000e+01, 6.3000e+00, 2.3000e+00, 4.4000e+00, 1.3000e+00],
        [8.9000e+01, 5.6000e+00, 3.0000e+00, 4.1000e+00, 1.3000e+00],
        [9.0000e+01, 5.5000e+00, 2.5000e+00, 4.0000e+00, 1.3000e+00],
        [9.1000e+01, 5.5000e+00, 2.6000e+00, 4.4000e+00, 1.2000e+00],
        [9.2000e+01, 6.1000e+00, 3.0000e+00, 4.6000e+00, 1.4000e+00],
        [9.3000e+01, 5.8000e+00, 2.6000e+00, 4.0000e+00, 1.2000e+00],
        [9.4000e+01, 5.0000e+00, 2.3000e+00, 3.3000e+00, 1.0000e+00],
        [9.5000e+01, 5.6000e+00, 2.7000e+00, 4.2000e+00, 1.3000e+00],
        [9.6000e+01, 5.7000e+00, 3.0000e+00, 4.2000e+00, 1.2000e+00],
        [9.7000e+01, 5.7000e+00, 2.9000e+00, 4.2000e+00, 1.3000e+00],
        [9.8000e+01, 6.2000e+00, 2.9000e+00, 4.3000e+00, 1.3000e+00],
        [9.9000e+01, 5.1000e+00, 2.5000e+00, 3.0000e+00, 1.1000e+00],
        [1.0000e+02, 5.7000e+00, 2.8000e+00, 4.1000e+00, 1.3000e+00],
        [1.0100e+02, 6.3000e+00, 3.3000e+00, 6.0000e+00, 2.5000e+00],
        [1.0200e+02, 5.8000e+00, 2.7000e+00, 5.1000e+00, 1.9000e+00],
        [1.0300e+02, 7.1000e+00, 3.0000e+00, 5.9000e+00, 2.1000e+00],
        [1.0400e+02, 6.3000e+00, 2.9000e+00, 5.6000e+00, 1.8000e+00],
        [1.0500e+02, 6.5000e+00, 3.0000e+00, 5.8000e+00, 2.2000e+00],
        [1.0600e+02, 7.6000e+00, 3.0000e+00, 6.6000e+00, 2.1000e+00],
        [1.0700e+02, 4.9000e+00, 2.5000e+00, 4.5000e+00, 1.7000e+00],
        [1.0800e+02, 7.3000e+00, 2.9000e+00, 6.3000e+00, 1.8000e+00],
        [1.0900e+02, 6.7000e+00, 2.5000e+00, 5.8000e+00, 1.8000e+00],
        [1.1000e+02, 7.2000e+00, 3.6000e+00, 6.1000e+00, 2.5000e+00],
        [1.1100e+02, 6.5000e+00, 3.2000e+00, 5.1000e+00, 2.0000e+00],
        [1.1200e+02, 6.4000e+00, 2.7000e+00, 5.3000e+00, 1.9000e+00],
        [1.1300e+02, 6.8000e+00, 3.0000e+00, 5.5000e+00, 2.1000e+00],
        [1.1400e+02, 5.7000e+00, 2.5000e+00, 5.0000e+00, 2.0000e+00],
        [1.1500e+02, 5.8000e+00, 2.8000e+00, 5.1000e+00, 2.4000e+00],
        [1.1600e+02, 6.4000e+00, 3.2000e+00, 5.3000e+00, 2.3000e+00],
        [1.1700e+02, 6.5000e+00, 3.0000e+00, 5.5000e+00, 1.8000e+00],
        [1.1800e+02, 7.7000e+00, 3.8000e+00, 6.7000e+00, 2.2000e+00],
        [1.1900e+02, 7.7000e+00, 2.6000e+00, 6.9000e+00, 2.3000e+00],
        [1.2000e+02, 6.0000e+00, 2.2000e+00, 5.0000e+00, 1.5000e+00],
        [1.2100e+02, 6.9000e+00, 3.2000e+00, 5.7000e+00, 2.3000e+00],
        [1.2200e+02, 5.6000e+00, 2.8000e+00, 4.9000e+00, 2.0000e+00],
        [1.2300e+02, 7.7000e+00, 2.8000e+00, 6.7000e+00, 2.0000e+00],
        [1.2400e+02, 6.3000e+00, 2.7000e+00, 4.9000e+00, 1.8000e+00],
        [1.2500e+02, 6.7000e+00, 3.3000e+00, 5.7000e+00, 2.1000e+00],
        [1.2600e+02, 7.2000e+00, 3.2000e+00, 6.0000e+00, 1.8000e+00],
        [1.2700e+02, 6.2000e+00, 2.8000e+00, 4.8000e+00, 1.8000e+00],
        [1.2800e+02, 6.1000e+00, 3.0000e+00, 4.9000e+00, 1.8000e+00],
        [1.2900e+02, 6.4000e+00, 2.8000e+00, 5.6000e+00, 2.1000e+00],
        [1.3000e+02, 7.2000e+00, 3.0000e+00, 5.8000e+00, 1.6000e+00],
        [1.3100e+02, 7.4000e+00, 2.8000e+00, 6.1000e+00, 1.9000e+00],
        [1.3200e+02, 7.9000e+00, 3.8000e+00, 6.4000e+00, 2.0000e+00],
        [1.3300e+02, 6.4000e+00, 2.8000e+00, 5.6000e+00, 2.2000e+00],
        [1.3400e+02, 6.3000e+00, 2.8000e+00, 5.1000e+00, 1.5000e+00],
        [1.3500e+02, 6.1000e+00, 2.6000e+00, 5.6000e+00, 1.4000e+00],
        [1.3600e+02, 7.7000e+00, 3.0000e+00, 6.1000e+00, 2.3000e+00],
        [1.3700e+02, 6.3000e+00, 3.4000e+00, 5.6000e+00, 2.4000e+00],
        [1.3800e+02, 6.4000e+00, 3.1000e+00, 5.5000e+00, 1.8000e+00],
        [1.3900e+02, 6.0000e+00, 3.0000e+00, 4.8000e+00, 1.8000e+00],
        [1.4000e+02, 6.9000e+00, 3.1000e+00, 5.4000e+00, 2.1000e+00],
        [1.4100e+02, 6.7000e+00, 3.1000e+00, 5.6000e+00, 2.4000e+00],
        [1.4200e+02, 6.9000e+00, 3.1000e+00, 5.1000e+00, 2.3000e+00],
        [1.4300e+02, 5.8000e+00, 2.7000e+00, 5.1000e+00, 1.9000e+00],
        [1.4400e+02, 6.8000e+00, 3.2000e+00, 5.9000e+00, 2.3000e+00],
        [1.4500e+02, 6.7000e+00, 3.3000e+00, 5.7000e+00, 2.5000e+00],
        [1.4600e+02, 6.7000e+00, 3.0000e+00, 5.2000e+00, 2.3000e+00],
        [1.4700e+02, 6.3000e+00, 2.5000e+00, 5.0000e+00, 1.9000e+00],
        [1.4800e+02, 6.5000e+00, 3.0000e+00, 5.2000e+00, 2.0000e+00],
        [1.4900e+02, 6.2000e+00, 3.4000e+00, 5.4000e+00, 2.3000e+00],
        [1.5000e+02, 5.9000e+00, 3.0000e+00, 5.1000e+00, 1.8000e+00]],
       dtype=torch.float64) tensor([[1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 1, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0],
        [0, 0, 1, 0]], dtype=torch.uint8)
tensor([[3., 1., 0., 0.],
        [2., 0., 0., 1.],
        [4., 0., 1., 0.],
        [3., 0., 0., 1.]], dtype=torch.float64) tensor([127500, 106000, 178100, 140000])
 

总结

经过了大半天的努力终于把这篇文章写完了，查阅了很多的资料，也问了很多人，虽说过程很艰难，但最后也是把这次实验的内容掌握的半斤八两。其中在对数据的储存中，我电脑Pytorch和CUDA版本不兼容，在一顿瞎整后依然没有解决，最后还是求助一位大佬才终于把这个问题解决，在处理数据集的时候，这些只是虽说之前学过一些，但经过了这一个假期忘的都差不多了，通过这次试验，有吧之前的一些家伙事掏出来看看，复习一下，之前本就学得不好，在这个数据集的处理给我难得够呛，感觉我太笨，不适合计算机这个专业。在查阅资料的时候，看那些大佬的文章才觉得计算机这个行业真是博大精深，读他们的文章，真是收益良多。

最后文章引用：

我们老师的博客：NNDL 实验二 pytorch入门_HBU_David的博客-CSDN博客NNDL 实验二 pytorch入门https://blog.csdn.net/qq_38975453/article/details/126491559

以及 邱锡鹏老师的《神经网络与深度学习》

NNDL 实验1 - HBU_DAVID - 博客园邱锡鹏，神经网络与深度学习，机械工业出版社，https://nndl.github.io/, 2020. https://github.com/nndl/practice-in-paddle/ 第1章https://www.cnblogs.com/hbuwyg/p/16617393.html