一、张量
1）定义：
不管是几阶数组都是张量
2）
在torch中张量有八种数据类型：
在torch中默认为32位浮点型的数据类型，可以通过torch.set_defoult_tensor_dtpype()更改默认的数据类型
import torch
torch.tensor([1.2,3.4]).dtype
out:torch.float32
更改类型：
torch.set_defoult_tensor_dtpype(torch.DoubleTensor)
torch.tensor([1.2,3.4]).dtype
out:torch.float64
将浮点型转化成其他类型的方法：
a=torch.tensor([1.2,3.4])
print("a.dtype:",a.dtype)
print("a.long().dtype:",a.long().dtype)
print("a.int().dtype:",a.int().dtype)
print("a.float().dtype:",a.float().dtype)out:
a.dtype: torch.float32
a.long().dtype: torch.int64
a.int().dtype: torch.int32
a.float().dtype: torch.float32
3)张量的生成
使用torch.Tensor()函数生成张量
a=torch.tensor([1.2,3.4])
print(a)tensor([1.2000, 3.4000])
获取维度：
b=a.shape获取形状大小：
c=a.size()计算所包含元素数量：
d=a.numel()out：torch.Size([2]) torch.Size([2]) 2
使用参数requirs_gard来指定张量是否要计算梯度，只有计算了梯度张量才能在深度网络优化中根据梯度大小进行更新。
B=torch.tensor([1,2,3]，requires_gard=True)
因为张量B是可计算梯度的，故可以计算sum（B**2）的梯度
B=torch.tensor((1,2,3),dtype=torch.float32,requires_grad=True)
y=B.pow(2).sum()
C=y.backward()
D=B.grad
print(C,D)out：None tensor([2., 4., 6.])
只有浮点型的数据才能计算梯度
还可以用torch.Tensor()函数
创建张量
c=torch.Temsor（[1,2,3,4]）
创建形状参数生成特定尺寸的张量
生成2*3的张量
D=torch.Temsor(2,3)
可以用torch.**_like()生成与指定张量维度形状相同的张量
如：
torch.ones_like(D)
out:tensor([[1.1.1],[1,1,1}])
随机张量：
torch.rand_like(D)
4)张量和numpy的转换
将Numpy转换成pytorch可以使用torch.as_tensor()和torch.from_numpy()
f=np.ones((3,3))
Ftensor=torch.as_tensor(F)
out:
tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]], dtype=torch.float64)
等等
二、张量操作
1）改变张量的形状
tensor.reshape()函数改变形状大小
A=torch.arange(12.0).reshape(3,4)
print(A)out：tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
使用resize_as_(B)的方法可使A的形状尺寸设置成与B一样
B=torch.arange(10.0,19.0).reshape(3,3)
print(B)
A=A.resize_as_(B)
print(A)tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]], dtype=torch.float64)
tensor([[10., 11., 12.],
[13., 14., 15.],
[16., 17., 18.]])
2）可以通过troch.unsqueeze()函数在指定维度插入尺寸为一的新张量
A=torch.arange(12.0).reshape(2,6)
B=torch.unsqueeze(A,dim=0)
c=B.shapetorch.Size([1, 2, 6])
移除指定张量为一的维度
C=B.unsqueeze(dim=3)
print(C.shape)
D=torch.squeeze(C)
print(D.shape)torch.Size([1, 2, 6, 1])
torch.Size([2, 6])
3）获取张量中的元素
和numpy的切片是一样的
4）拼接张量用torch.cat函数
拆分用torch.chunk函数
三、张量的计算
1）比较两个元素是否接近：
判断两个元素是否相等：
torch.eq(A,B)
判断两个张量是否有相同的形状和元素
torch.equal(A,B)
逐元素比较是否大于等于：
torch.ge(A,B)
逐元素比较大于：
torch.gt(A,B)
torch.le()逐元素比较小于等于，torch.lt逐元素比较小于
torch.ne逐元素比较不等于
2）基本运算
乘：A*B
除：A\B
减：A-B
加：A+B
整除:A\\B
幂用torch.pow(A,2)或者**2
指数用torch.exp()
对数用torch.log()
torch.sort排序
等等
四、层模块
torch.nn
1)卷积层
内容概要：
卷积可以看作是输入与卷积核之间的内积运算；
使用卷积运算在图像识别，图像分割，图像重建等方面有三个好处：
1、在卷积神经网络中通过输入卷积核进行卷积操作，使输入单元（图像或特征单元）和输出单元（特征映射）之间的连接是稀疏的，这样可以减少训练参数的数量，从而加快网络的计算速度。
2、卷积操作的参数共享特点可使同一组模型同一组参数可以呗多个函数共享使用
3、等变表示，
以torch.nn.Conv2d()为例介绍卷积在图像上的使用方法
torch.nn.Conv2d(in_channels,
out_channels,
kernel_size,
stride=1,
padding=0,
dilation=1,
groups=1,
bias=True)
2)池化层
池化操作的目的是对卷积后得到的特征进行进一步的处理主要是降维，池化层可以对数据起到进一步浓缩的效果，从而降低计算的缓存压力。
池化会选择一个区域，如果该区域像素值用平均元素值表式称之为平均值池化，如果使用最大值表示称之为最大值池化。
可见池化后特征映射的尺寸变小，图像变模糊
3）激活函数
4）循环层
5）全连接层
一个或多个神经元组成的层；
所有的输入和输出都有连接，每个输入都会影响所有神经元的输出；
全连接层应用十分广泛，只有全连接层组成的全连接神经网络可用数据的分类和预测，卷积神经网络的末端通常会由多个全连接层组成。
四、数据操作和预处理
1）高维数组
很多情况下我们要从文本文件中读取高维数组数据，这类数据的特征是每个样本都有很多有的预测变量（特征）和一个被预测变量（目标标签），特征通常是数值变量或者离散变量，被预测变量如果是连续的值，则对应着回归问题的预测如果是离散变量则对应着分类问题；
使用pytorch进行建立模型时通常要对数据进行处理将他们转化成网络需要的类型。
回归数据准备：
import torch
import torch.utils.data as Data
import numpy as np
from sklearn.datasets import load_boston,load_iris
boston_x,boston_y=load_boston(return_X_y=True)#读取波士顿数据
print("boston_x_data:",boston_x.dtype)
print("boston_y_data:",boston_y.dtype)
##将64位浮点数转化成32位浮点数
##训练集x，y转化为张量
train_xt=torch.from_numpy(boston_x.astype(np.float32))
train_yt=torch.from_numpy(boston_y.astype(np.float32))
print("train_xt:",train_xt.dtype)
print("train_yt:",train_yt.dtype)
#使用tensorDataset
train_data=Data.TensorDataset(train_xt,train_yt)
##定义一个数据加载器，将训练数据批量整理
train_loader=Data.DataLoader(dataset=train_data,##使用的数据集
batch_size=64,##批处理样本大小
shuffle=True)##每次迭代前打乱数据
# num_workers=1)##使用两个进程
##检查数据集的一个batch的样本维度是否正确
for step,(b_x,b_y) in enumerate(train_loader):
if step>0:
break
##输出训练的图像的尺寸标签和数据类型
print("b_xshape:",b_x.shape)
print("b_yshape:",b_y.shape)
print("b_xtype:",b_x.dtype)
print("b_ytype:",b_y.dtype)
输出：
boston_x_data: float64
boston_y_data: float64
train_xt: torch.float32
train_yt: torch.float32
b_xshape: torch.Size([64, 13])
b_yshape: torch.Size([64])
b_xtype: torch.float32
b_ytype: torch.float32
分类数据：
分类数据和回归数据的不同点在于分类数据的被预测变量为离散类变量，所以在使用pytorch定义网络模型时，默认标签时64位有符号整型数据。
import torch
import torch.utils.data as Data
import numpy as np
from sklearn.datasets import load_boston,load_iris
##处理分类数据
iris_x,iris_y=load_iris(return_X_y=True)
print("iris_x.dtype:",iris_x.dtype)
print("iris_y.dtype:",iris_y.dtype)
##在torch构建的网络中，X默认的类型是troch.float32,Y默认为64位int整形
train_xt=torch.from_numpy(iris_x.astype(np.float32))
train_yt=torch.from_numpy(iris_y.astype(np.int64))
print("train_xt:",train_xt.dtype)
print("train_yt:",train_yt.dtype)
##定义数据加载器
##将训练集转化为张量后用TensorDataset将X和Y整理到一起
train_data=Data.TensorDataset(train_xt,train_yt)
train_loader=Data.DataLoader(dataset=train_data,##使用的数据集
batch_size=10,##批处理样本大小
shuffle=True)##每次迭代前打乱数据
# num_workers=1)##使用两个进程
##检查数据集的一个batch的样本维度是否正确
for step,(b_x,b_y) in enumerate(train_loader):
if step>0:
break
##输出训练的图像的尺寸标签和数据类型
print("b_xshape:",b_x.shape)
print("b_yshape:",b_y.shape)
print("b_xtype:",b_x.dtype)
print("b_ytype:",b_y.dtype)输出：
iris_x.dtype: float64
iris_y.dtype: int32
train_xt: torch.float32
train_yt: torch.int64
b_xshape: torch.Size([10, 4])
b_yshape: torch.Size([10])
b_xtype: torch.float32
b_ytype: torch.int64
图像数据：
torchvision准备好了一些数据集：
transforms模块可对每张图像进行预处理操作做；
处理torch中的衣服照片数据：
import torch
import torch.utils.data as Data
from torchvision.datasets import FashionMNIST
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder
##使用FashionMNIST数据，准备训练集
test_data=FashionMNIST(root="./data/FashionMNIST",##数据的路径'.'表示当前代码的文件路径
train=True,##只是用训练集
transform=transforms.ToTensor(),
download=True)##是否下载数据
train_loader=Data.DataLoader(dataset=test_data,##使用的数据集
batch_size=10,##批处理样本大小
shuffle=True)##每次迭代前打乱数据
# num_workers=1)##使用两个进程
##计算train_loader有多少个batch
print("batch的数量为：",len(train_loader))
test_data_x=test_data.type(torch.FloatTensor)
test_data_x=torch.unsqueeze(test_data_x,dim=1)
test_data_y=test_data.targets
print("test_data_x.shape:",test_data_x.shape)
print("test_data_y.shape:",test_data_y.shape)五、随机梯度下降算法
在深度学习网络中，通常设计一个损失函数来约束我们模型训练的过程；
如针对分类问题可以使用交叉嫡损失，针对回归问题可用均方根误差损失，训练的模型不是漫无目的的而是朝着最小化损失函数的方向去训练，这时就会用到梯度下降算法。
随机梯度下降算法每次只选取一部分样本进行优化，样本的数量一般是二的整数次幂，取值范围是32--256，是深度学习优化网络中最常用的算法。
六、pytorch中的优化器、
opyim模块提供了多种深度学习优化算法，无需人工实现随机梯度下降算法；
以adam类为例：
七、损失函数
1）均方差损失：
2）交叉嫡损失：
分类问题中，交叉熵函数是比较常用也是比较基础的损失函数，交叉熵能够表征真实样本标签和预测概率之间的差值；
3）防止过拟合
方法：
1.增加数据量如在图像分类任务中物体在图像中的位置，姿态，尺度，图像的明暗都会影响分类结果，所以可用平移旋转缩放等对数据进行扩充。
2.合理的数据切分
针对数据量不同，划分的比例也不同；
如传统为60：20：20；
而对于几百万级别的大数据可能是98：1：1
3.正则化的方法
在损失函数的基础上添加对训练参数的惩罚系数
4。Dropout
引入Dropout随机丢掉一些神经元
5提前结束训练
八、网络参数的初始化
未完待续。。。
扫一扫
663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
