深度学习框架PyTorch一书的学习-第四章-神经网络工具箱nn

参考https://github.com/chenyuntc/pytorch-book/tree/v1.0

希望大家直接到上面的网址去查看代码,下面是本人的笔记

 

本章介绍的nn模块是构建与autograd之上的神经网络模块

除了nn外还会介绍神经网络中常用的工具,比如优化器optim、初始化init等

1.nn.Module

torch的核心数据结构是Module,它是一个抽象的概念,既可以表示神经网络中的某个层,也可以表示一个包含很多层的神经网络

在实际使用中,最常见的做法是继承nn.Module,攥写自己的网络层

下面先来看看如何使用nn.Module实现自己的全连接层。全连接层,又名仿射层,输出y和输入x满足y=Wx +b,W和b是可以学习的参数

import torch as t
from torch import nn
from torch.autograd import Variable as V

定义函数:

class Linear(nn.Module): #继承nn.Moduledef __init__(self, in_features, out_features):super(Linear, self).__init__() #等价于nn.Module.__init__(self)self.w = nn.Parameter(t.randn(in_features,out_features)) #参数的命名规范下面会说明self.b = nn.Parameter(t.randn(out_features))def forward(self, x):x = x.mm(self.w)return x + self.b.expand_as(x)

运行:

layer = Linear(4,3)
input = V(t.randn(2,4))
output = layer(input)
output

返回:

tensor([[-0.4199,  3.7252,  1.9104],[ 2.3267,  2.0576, -2.9361]], grad_fn=<AddBackward0>)

查看参数:

for name, parameter in layer.named_parameters():print(name, parameter) #即w,b

返回:

w Parameter containing:
tensor([[ 1.1147, -0.8054, -0.7915],[-0.3828,  0.1073,  2.0440],[-0.3297,  0.0465,  0.0759],[ 0.1022,  0.1638,  1.0872]], requires_grad=True)
b Parameter containing:
tensor([ 1.2872,  2.3990, -0.7711], requires_grad=True)

可见,全连接层的实现非常简单,其代码量不超过10行,但需注意以下几点:

  • 自定义层Linear必须继承nn.Module,并且在其构造函数中需调用nn.Module的构造函数,即super(Linear, self).__init__() 或nn.Module.__init__(self),推荐使用第一种用法,尽管第二种写法更直观。
  • 在构造函数__init__中必须自己定义可学习的参数,并封装成Parameter,如在本例中我们把wb封装成parameterparameter是一种特殊的Variable,但其默认需要求导(requires_grad = True),感兴趣的读者可以通过nn.Parameter??,查看Parameter类的源代码。
  • forward函数实现前向传播过程,其输入可以是一个或多个variable,对x的任何操作也必须是variable支持的操作。
  • 无需写反向传播函数,因其前向传播都是对variable进行操作,nn.Module能够利用autograd自动实现反向传播,这点比Function简单许多。
  • 使用时,直观上可将layer看成数学概念中的函数,调用layer(input)即可得到input对应的结果。它等价于layers.__call__(input),在__call__函数中,主要调用的是 layer.forward(x),另外还对钩子做了一些处理。所以在实际使用中应尽量使用layer(x)而不是使用layer.forward(x),关于钩子技术将在下文讲解。
  • Module中的可学习参数可以通过named_parameters()或者parameters()返回迭代器,前者会给每个parameter都附上名字,使其更具有辨识度。

可见利用Module实现的全连接层,比利用Function实现的更为简单,因其不再需要写反向传播函数。

Module能够自动检测到自己的Parameter,并将其作为学习参数。除了parameter之外,Module还包含子Module,主Module能够递归查找子Module中的parameter。下面再来看看稍微复杂一点的网络,多层感知机。

多层感知机的网络结构如图4-1所示,它由两个全连接层组成,采用$sigmoid$函数作为激活函数,图中没有画出。

class Perceptron(nn.Module):def __init__(self, in_features, hidden_features, out_features):super(Perceptron, self).__init__()self.layer1 = Linear(in_features, hidden_features) #使用的是上面定义的Linear函数self.layer2 = Linear(hidden_features, out_features)def forward(self, x):x = self.layer1(x)x = t.sigmoid(x) #激活函数return self.layer2(x)

调用:

perceptron = Perceptron(3,4,1)
for name, param in perceptron.named_parameters():print(name, param.size())

返回:

layer1.w torch.Size([3, 4])
layer1.b torch.Size([4])
layer2.w torch.Size([4, 1])
layer2.b torch.Size([1])


可见,即使是稍复杂的多层感知机,其实现依旧很简单。这里新增两个知识点:

  • 构造函数__init__中,可利用前面自定义的Linear层(module),作为当前module对象的一个子module,它的可学习参数,也会成为当前module的可学习参数。
  • 在前向传播函数中,我们有意识地将输出变量都命名成x,是为了能让Python回收一些中间层的输出,从而节省内存。但并不是所有都会被回收,有些variable虽然名字被覆盖,但其在反向传播仍需要用到,此时Python的内存回收模块将通过检查引用计数,不会回收这一部分内存。

module中parameter的命名规范:

  • 对于类似self.param_name = nn.Parameter(t.randn(3, 4)),命名为param_name
  • 对于子Module中的parameter,会其名字之前加上当前Module的名字。如对于self.sub_module = SubModel(),SubModel中有个parameter的名字叫做param_name,那么二者拼接而成的parameter name 就是sub_module.param_name

为方便用户使用,PyTorch实现了神经网络中绝大多数的layer,这些layer都继承于nn.Module,封装了可学习参数parameter,并实现了forward函数,且很多都专门针对GPU运算进行了CuDNN优化,其速度和性能都十分优异。本书不准备对nn.Module中的所有层进行详细介绍,具体内容读者可参照官方文档。阅读文档时应主要关注以下几点:

  • 构造函数的参数,如nn.Linear(in_features, out_features, bias),需关注这三个参数的作用。
  • 属性,可学习参数,子module。如nn.Linear中有weightbias两个可学习参数,不包含子module。
  • 输入输出的形状,如nn.linear的输入形状是(N, input_features),输出为(N,output_features),N是batch_size。

这些自定义layer对输入形状都有假设:输入的不是单个数据,而是一个batch。

若想输入一个数据,则必须调用unsqueeze(0)函数将数据伪装成batch_size=1的batch

 

下面将从应用层面出发,对一些常用的layer做简单介绍,更详细的用法请查看文档,这里只作概览参考。

2.常用神经网络层

1.图像相关层

图像相关层主要包括卷积层(Conv)、池化层(Pool)等,这些层在实际使用中可分为一维(1D)、二维(2D)、三维(3D),池化方式又分为平均池化(AvgPool)、最大值池化(MaxPool)、自适应池化(AdaptiveAvgPool)等。而卷积层除了常用的前向卷积之外,还有逆卷积(TransposeConv)。下面举例说明一些基础的使用。

from PIL import Image
from torchvision.transforms import ToTensor, ToPILImage
to_tensor = ToTensor() #img -> tensor
to_pil = ToPILImage()
lena = Image.open('imgs/lena.png') #这是个灰度图像
lena

返回图片:

#输入是一个batch,batch_size = 1
print(lena.size) #(1200200)
input = to_tensor(lena).unsqueeze(0) #变成(1,1,200,200)
print(input)
#锐化卷积核 kernel
= t.ones(3 ,3)/-9 kernel[1][1] = 1 conv = nn.Conv2d(1, 1, (3,3), 1, bias = False) conv.weight.data = kernel.view(1,1,3,3)out = conv(V(input)) to_pil(out.data.squeeze(0))

返回:

(200, 200)
tensor([[[[0.6353, 0.6314, 0.6314,  ..., 0.6118, 0.6667, 0.5922],[0.6353, 0.6314, 0.6314,  ..., 0.6078, 0.6510, 0.5647],[0.6275, 0.6235, 0.6235,  ..., 0.4824, 0.4157, 0.3098],...,[0.1961, 0.2078, 0.2078,  ..., 0.2510, 0.3098, 0.3412],[0.1922, 0.2000, 0.2039,  ..., 0.3098, 0.3686, 0.3804],[0.1843, 0.2078, 0.1961,  ..., 0.3569, 0.3961, 0.4078]]]])

图示:

 

池化层可以看作是一种特殊的卷积层,用来下采样。但池化层没有可学习参数,其weight是固定的。

 

pool = nn.AvgPool2d(2,2) #平均池化
list(pool.parameters()) #返回[],因为无参数

 

out = pool(input) #对数据进行池化
to_pil(out.data.squeeze(0)) #显示结果

图示:

 

除了卷积层和池化层,深度学习中还将常用到以下几个层:

  • Linear:全连接层。
  • BatchNorm:批规范化层,分为1D、2D和3D。除了标准的BatchNorm之外,还有在风格迁移中常用到的InstanceNorm层。
  • Dropout:dropout层,用来防止过拟合,同样分为1D、2D和3D。 下面通过例子来说明它们的使用。

1)全连接层

#输入batch_size = 2,维度为3
input = t.randn(2,3)
linear = nn.Linear(3,4)
h = linear(input)
h

返回:

tensor([[ 0.5406, -0.0327,  0.7291,  0.5262],[ 0.1471, -0.1924,  0.8960,  0.7801]], grad_fn=<AddmmBackward>)

2)批规范化,即归一化层

#4 channel,初始化标准差为4,均值为0
bn = nn.BatchNorm1d(4) #对小批量(mini-batch)的2d或3d输入进行批标准化(Batch Normalization)操作,即归一化
bn.weight.data = t.ones(4) * 4
bn.bias.data = t.zeros(4)bn_out = bn(h)
#注意输出的均值和方差
#方差是标准差的平方,计算无偏方差分母会减1
#使用unbiased=False 分母不减1
bn_out.mean(0), bn_out.var(0, unbiased=False) #归一化后平均值为0,方差为标准单位方差

返回:

(tensor([0., 0., 0., 0.], grad_fn=<MeanBackward0>),tensor([15.9959, 15.9749, 15.9771, 15.9901], grad_fn=<VarBackward1>))

Batch归一化使用在z上,下面激活函数处的例子可见,对其进行卷积 -> batch归一化 -> 激活函数

3)dropout正则化层

#每个元素以0.5的概率舍弃,实现dropout正则化,消除过拟合问题
dropout = nn.Dropout(0.5)
o = dropout(bn_out)
o #有一半左右的数变成0

返回:

tensor([[ 0.0000,  7.9937, -7.9943, -7.9975],[-0.0000, -0.0000,  7.9943,  7.9975]], grad_fn=<MulBackward0>)

以上很多例子中都对module的属性直接操作,其大多数是可学习参数,一般会随着学习的进行而不断改变。实际使用中除非需要使用特殊的初始化,应尽量不要直接修改这些参数。

 

2.激活函数

1)ReLu


$$ReLU(x)=max(0,x)$$

relu = nn.ReLU(inplace=True)
input = t.randn(2,3)
print(input)
output = relu(input)
print(output) #小于0的都被截断为0
#等价于input.clamp(min=0)

返回:

tensor([[ 1.2619, -0.9128,  0.6259],[-1.4834,  0.7297, -0.8562]])
tensor([[1.2619, 0.0000, 0.6259],[0.0000, 0.7297, 0.0000]])

ReLU函数有个inplace参数,如果设为True,它会把输出直接覆盖到输入中,这样可以节省内存/显存。之所以可以覆盖是因为在计算ReLU的反向传播时,只需根据输出就能够推算出反向传播的梯度

但是只有少数的autograd操作支持inplace操作(如tensor.sigmoid_()),除非你明确地知道自己在做什么,否则一般不要使用inplace操作。

 

在以上的例子中,基本上都是将每一层的输出直接作为下一层的输入,这种网络称为前馈传播网络(feedforward neural network)。

⚠️

对于此类网络如果每次都写复杂的forward函数会有些麻烦,在此就有两种简化方式,ModuleList和Sequential。其中Sequential是一个特殊的module,它包含几个子Module,前向传播时会将输入一层接一层的传递下去。ModuleList也是一个特殊的module,可以包含几个子module,可以像用list一样使用它,但不能直接把输入传给ModuleList。下面举例说明。

1)Sequential

#Sequential的三种写法
#第一种
net1 = nn.Sequential()
net1.add_module('conv', nn.Conv2d(3,3,3))
net1.add_module('batchnorm', nn.BatchNorm2d(3))
net1.add_module('activation_layer', nn.ReLU())#第二种
net2 = nn.Sequential(nn.Conv2d(3,3,3),nn.BatchNorm2d(3),nn.ReLU())#第三种
from collections import OrderedDict
net3 = nn.Sequential(OrderedDict([('conv1', nn.Conv2d(3,3,3)),('bn1', nn.BatchNorm2d(3)),('relu1',nn.ReLU())]))
print('net1:', net1)
print('net2:', net2)
print('net3:', net3)

返回:

net1: Sequential((conv): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))(batchnorm): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(activation_layer): ReLU()
)
net2: Sequential((0): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))(1): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(2): ReLU()
)
net3: Sequential((conv1): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))(bn1): BatchNorm2d(3, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(relu1): ReLU()
)

 

#可根据名字后序号取出子module
net1.conv, net2[0], net3.conv1

返回:

(Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)),Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)),Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1)))

调用方式为:

input = t.rand(1,3,4,4)
output1 = net1(input)
output2 = net2(input)
output3 = net3(input)
output4 = net3.relu1(net1.batchnorm(net1.conv(input)))

 

2)ModuleList

modellist = nn.ModuleList([nn.Linear(3,4), nn.ReLU(), nn.Linear(4,2)])
input = t.randn(1,3)
for model in modellist:input = model(input)
print(input)

返回:

tensor([[-0.6547,  0.8027]], grad_fn=<AddmmBackward>)

 

# 下面会报错,因为modellist没有实现forward方法
output = modellist(input)

看到这里,读者可能会问,为何不直接使用Python中自带的list,而非要多此一举呢?这是因为ModuleListModule的子类,当在Module中使用它的时候,就能自动识别为子module。

下面举一个实现forward的例子进行说明:

class MyModule(nn.Module):def __init__(self):super(MyModule, self).__init__()self.list = [nn.Linear(3,4), nn.ReLU()]self.module_list = nn.ModuleList([nn.Conv2d(3,3,3), nn.ReLU()])def forward(self):pass
model = MyModule()
model

返回:

MyModule((module_list): ModuleList((0): Conv2d(3, 3, kernel_size=(3, 3), stride=(1, 1))(1): ReLU())
)

查看参数:

for name, param in model.named_parameters():print(name, param.size())

返回:

module_list.0.weight torch.Size([3, 3, 3, 3])
module_list.0.bias torch.Size([3])

可见,list中的子module并不能被主module所识别,而ModuleList中的子module能够被主module所识别。这意味着如果用list保存子module,将无法调整其参数,因其未加入到主module的参数中。

除ModuleList之外还有ParameterList,其是一个可以包含多个parameter的类list对象。在实际应用中,使用方式与ModuleList类似。

如果在构造函数__init__中用到list、tuple、dict等对象时,一定要思考是否应该用ModuleList或ParameterList代替。

 

3.循环神经网络层(后面好好看看)

近些年随着深度学习和自然语言处理的结合加深,RNN的使用也越来越多,关于RNN的基础知识,推荐阅读colah的文章1入门。PyTorch中实现了如今最常用的三种RNN:RNN(vanilla RNN)、LSTM和GRU。此外还有对应的三种RNNCell。

RNN和RNNCell层的区别在于前者一次能够处理整个序列,而后者一次只处理序列中一个时间点的数据,前者封装更完备更易于使用,后者更具灵活性。实际上RNN层的一种后端实现方式就是调用RNNCell来实现的。

t.manual_seed(1000)
# 输入:batch_size=3,序列长度都为2,序列中每个元素占4维
input = t.randn(2, 3, 4)
# lstm输入向量4维,隐藏元3,1层
lstm = nn.LSTM(4, 3, 1)
# 初始状态:1层,batch_size=3,3个隐藏元
h0 = t.randn(1, 3, 3)
c0 = t.randn(1, 3, 3)
out, hn = lstm(input, (h0, c0))
out

返回:

tensor([[[-0.3610, -0.1643,  0.1631],[-0.0613, -0.4937, -0.1642],[ 0.5080, -0.4175,  0.2502]],[[-0.0703, -0.0393, -0.0429],[ 0.2085, -0.3005, -0.2686],[ 0.1482, -0.4728,  0.1425]]], grad_fn=<StackBackward>)

 

t.manual_seed(1000)
input = t.randn(2, 3, 4)
# 一个LSTMCell对应的层数只能是一层
lstm = nn.LSTMCell(4, 3)
hx = t.randn(3, 3)
cx = t.randn(3, 3)
out = []
for i_ in input:hx, cx=lstm(i_, (hx, cx))out.append(hx)
t.stack(out)

返回:

tensor([[[-0.3610, -0.1643,  0.1631],[-0.0613, -0.4937, -0.1642],[ 0.5080, -0.4175,  0.2502]],[[-0.0703, -0.0393, -0.0429],[ 0.2085, -0.3005, -0.2686],[ 0.1482, -0.4728,  0.1425]]], grad_fn=<StackBackward>)

 

# 有4个词,每个词用5维的向量表示
embedding = nn.Embedding(4, 5)
# 可以用预训练好的词向量初始化embedding
embedding.weight.data = t.arange(0,20).view(4,5)
input = t.arange(3, 0, -1).long()
output = embedding(input)
output

返回:

tensor([[15, 16, 17, 18, 19],[10, 11, 12, 13, 14],[ 5,  6,  7,  8,  9]], grad_fn=<EmbeddingBackward>)

 

4.损失函数

这里以分类中最常用的交叉熵损失CrossEntropyloss为例说明:

#batch_size = 3,计算对应每个类别的分数(只有两个类别)
score = t.randn(3,2)
#三个样本分别属于1,0,1类,label必须是LongTensor
label = t.Tensor([1,0,1]).long()#loss与普通的layer无差异
criterion = nn.CrossEntropyLoss()
loss = criterion(score, label)
loss #返回tensor(0.5944)

 

5.优化器

PyTorch将深度学习中常用的优化方法全部封装在torch.optim中,其设计十分灵活,能够很方便的扩展成自定义的优化方法。

所有的优化方法都是继承基类optim.Optimizer,并实现了自己的优化步骤。下面就以最基本的优化方法——随机梯度下降法(SGD)举例说明。这里需重点掌握:

  • 优化方法的基本使用方法
  • 如何对模型的不同部分设置不同的学习率
  • 如何调整学习率
#首先定义一个LeNet网络
class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.features = nn.Sequential(nn.Conv2d(3,6,5),nn.ReLU(),nn.MaxPool2d(2,2),nn.Conv2d(6,16,5),nn.ReLU(),nn.MaxPool2d(2,2))self.classifier = nn.Sequential( #全连接层nn.Linear(16*5*5, 120),nn.ReLU(),nn.Linear(120, 84),nn.ReLU(),nn.Linear(84, 10))def forward(self, x):x = self.features(x)x = x.view(-1,16*5*5) #将数据扁平化处理用传入全连接层x = self.classifier(x)return x
net = Net()

 

from torch import optim
optimizer = optim.SGD(params=net.parameters(), lr=1)
optimizer.zero_grad() #梯度清零,等价于net.zero_grad()input = t.randn(1,3,32,32)
output = net(input)
output.backward(output) #fake backward,后向传播,计算梯度optimizer.step() #执行优化

 

# 为不同子网络设置不同的学习率,在finetune中经常用到
# 如果对某个参数不指定学习率,就使用最外层的默认学习率
optimizer = optim.SGD([{'params' : net.features.parameters()}, #学习率为1e-5{'params' : net.classifier.parameters(), 'lr':1e-2}], lr=1e-5)
optimizer

返回:

SGD (
Parameter Group 0dampening: 0lr: 1e-05momentum: 0nesterov: Falseweight_decay: 0Parameter Group 1dampening: 0lr: 0.01momentum: 0nesterov: Falseweight_decay: 0
)

 

# 只为两个全连接层设置较大的学习率,其余层的学习率较小
special_layers = nn.ModuleList([net.classifier[0], net.classifier[2]])
special_layers_params = list(map(id, special_layers.parameters()))
base_params = filter(lambda p: id(p) not in special_layers_params, net.parameters())optimizer = t.optim.SGD([{'params': base_params},{'params': special_layers.parameters(), 'lr': 0.01}], lr=0.001 )
optimizer

返回:

SGD (
Parameter Group 0dampening: 0lr: 0.001momentum: 0nesterov: Falseweight_decay: 0Parameter Group 1dampening: 0lr: 0.01momentum: 0nesterov: Falseweight_decay: 0
)


对于如何调整学习率,主要有两种做法:

  • 一种是更简单也是较为推荐的做法——新建优化器,由于optimizer十分轻量级,构建开销很小,故而可以构建新的optimizer。但是后者对于使用动量的优化器(如Adam),会丢失动量等状态信息,可能会造成损失函数的收敛出现震荡等情况。
  • 一种是修改optimizer.param_groups中对应的学习率

1)新建优化器

#方法1:调整学习率,新建一个optimizer
old_lr = 0.1
optimizer1 = optim.SGD([{'params': net.features.parameters()},{'params': net.classifier.parameters(), 'lr':old_lr *0.1}
], lr = 1e-5)
optimizer1

返回:

SGD (
Parameter Group 0dampening: 0lr: 1e-05momentum: 0nesterov: Falseweight_decay: 0Parameter Group 1dampening: 0lr: 0.010000000000000002momentum: 0nesterov: Falseweight_decay: 0
)

2)调整学习率

#方法2:调整学习率,手动衰减,保存动量
for param_group in optimizer.param_groups:param_group['lr'] *= 0.1
optimizer

返回:

SGD (
Parameter Group 0dampening: 0lr: 0.0001momentum: 0nesterov: Falseweight_decay: 0Parameter Group 1dampening: 0lr: 0.001momentum: 0nesterov: Falseweight_decay: 0
)

 

3.nn.functional

nn中还有一个很常用的模块:nn.functional,nn中的大多数layer,在functional中都有一个与之相对应的函数。

nn.functional中的函数和nn.Module的主要区别在于:

  • nn.Module实现的layers是一个特殊的类,都是由class layer(nn.Module)定义,会自动提取可学习的参数
  • nn.functional中的函数更像是纯函数,由def function(input)定义。

下面举例说明functional的使用,并指出二者的不同之处。

input = t.randn(2,3)
model = nn.Linear(3,4)
output1 = model(input)
#使用上面使用的w,b,两种写法返回的结果是相同的
output2 = nn.functional.linear(input, model.weight, model.bias)
output1 == output2

返回:

tensor([[1, 1, 1, 1],[1, 1, 1, 1]], dtype=torch.uint8)

 

b = nn.functional.relu(input)
b2 = nn.ReLU()(input)
b == b2

返回:

tensor([[1, 1, 1],[1, 1, 1]], dtype=torch.uint8)

此时读者可能会问,应该什么时候使用nn.Module,什么时候使用nn.functional呢?

答案很简单,如果模型有可学习的参数,最好用nn.Module,否则既可以使用nn.functional也可以使用nn.Module,二者在性能上没有太大差异,具体的使用取决于个人的喜好。

如激活函数(ReLU、sigmoid、tanh),池化(MaxPool)等层由于没有可学习参数,则可以使用对应的functional函数代替,而对于卷积、全连接等具有可学习参数的网络建议使用nn.Module

下面举例说明,如何在模型中搭配使用nn.Module和nn.functional。

⚠️另外虽然dropout操作也没有可学习操作,但建议还是使用nn.Dropout而不是nn.functional.dropout,因为dropout在训练和测试两个阶段的行为有所差别,使用nn.Module对象能够通过model.eval操作加以区分

from torch.nn import functional as F
class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(3,6,5)self.conv2 = nn.Conv2d(6,16,5)self.fc1 = nn.Linear(16*5*5, 120)self.fc2 = nn.Linear(120,84)self.fc3 = nn.Linear(84, 10)def forward(self,x):x = F.pool(F.relu(self.conv1(x)),2)x = F.pool(F.relu(self.conv2(x)),2)x = x.view(-1, 16*5*5)x = F.relu(self.fc1(x))x = F.relu(self.fc2(x))        x = self.fc3(x)return x


对于不具备可学习参数的层(激活层、池化层等),将它们用函数代替,这样则可以不用放置在构造函数__init__中。对于有可学习参数的模块,也可以用functional来代替,只不过实现起来较为繁琐,需要手动定义参数parameter,如前面实现自定义的全连接层,就可将weight和bias两个参数单独拿出来,在构造函数中初始化为parameter。

class MyLinear(nn.Module):def __init__(self):super(MyLinear, self).__init__()self.weight = nn.Parameter(t.randn(3,4))self.bias = nn.Parameter(t.zeros(3))def forward(self):return F.linear(input, weight, bias)

 

4.初始化策略

在深度学习中参数的初始化十分重要,良好的初始化能让模型更快收敛,并达到更高水平,而糟糕的初始化则可能使得模型迅速瘫痪。

PyTorch中nn.Module的模块参数都采取了较为合理的初始化策略,因此一般不用我们考虑,当然我们也可以用自定义初始化去代替系统的默认初始化。而当我们在使用Parameter时,自定义初始化则尤为重要,因t.Tensor()返回的是内存中的随机数,很可能会有极大值,这在实际训练网络中会造成溢出或者梯度消失

PyTorch中nn.init模块就是专门为初始化而设计,如果某种初始化策略nn.init不提供,用户也可以自己直接初始化。

 

使用的初始化策略是:

torch.nn.init.xavier_normal_(tensor, gain=1)

参数:

  • tensor – n维的torch.Tensor
  • gain - 可选的缩放因子

用一个正态分布生成值,填充输入的张量或变量。结果张量中的值采样自均值为0,标准差为gain * sqrt(2/(fan_in + fan_out))的正态分布。也被称为Glorot initialisation.

1)直接初始化:

#利用nn.init初始化
from torch.nn import init
linear = nn.Linear(3,4)t.manual_seed(1)
#等价于linear.weight.data.normal_(0, std),std是正态分布的标准差
init.xavier_normal_(linear.weight)

返回:

Parameter containing:
tensor([[ 0.3535,  0.1427,  0.0330],[ 0.3321, -0.2416, -0.0888],[-0.8140,  0.2040, -0.5493],[-0.3010, -0.4769, -0.0311]], requires_grad=True)

2)手动初始化

#手动初始化
import math
t.manual_seed(1)#xavier初始化的计算公式
std = math.sqrt(2)/math.sqrt(7.)#3+4 = 7
linear.weight.data.normal_(0, std)

返回:

tensor([[ 0.3535,  0.1427,  0.0330],[ 0.3321, -0.2416, -0.0888],[-0.8140,  0.2040, -0.5493],[-0.3010, -0.4769, -0.0311]])

 

#对模型的所有参数进行初始化
for name, params in net.named_parameters():if name.find('linear') != -1:#init linearparams[0] #weightparams[1] #biaselif name.find('conv') != -1:passelif name.find('norm') != -1:pass

 

5.nn.Module深入分析

如果想要更深入地理解nn.Module,究其原理是很有必要的。首先来看看nn.Module基类的构造函数:

其中每个属性的解释如下:

  • _parameters:字典,保存用户直接设置的parameter,self.param1 = nn.Parameter(t.randn(3, 3))会被检测到,在字典中加入一个key为'param',value为对应parameter的item。而self.submodule = nn.Linear(3, 4)中的parameter则不会存于此
  • _modules:子module,通过self.submodel = nn.Linear(3, 4)指定的子module会保存于此。
  • _buffers:缓存。如batchnorm使用momentum机制,每次前向传播需用到上一次前向传播的结果。
  • _backward_hooks_forward_hooks:钩子技术,用来提取中间变量,类似variable的hook。
  • trainingBatchNorm与Dropout层在训练阶段和测试阶段中采取的策略不同,通过判断training值来决定前向传播策略

上述几个属性中,_parameters_modules_buffers这三个字典中的键值,都可以通过self.key方式获得,效果等价于self._parameters['key'].

下面举例说明:

1)定义网络:

class Net(nn.Module):def __init__(self):super(Net, self).__init__()#等价于self.register_parameter('param1', nn.Parameter(t.randn(3,3)))self.param1 = nn.Parameter(t.rand(3,3))self.submodel1 = nn.Linear(3,4)def forward(self, input):x = self.param1.mm(input)x = self.submodel1(x)return x
net = Net()
net

返回:

Net((submodel1): Linear(in_features=3, out_features=4, bias=True)
)

2)

net._modules #查看设置的子模块

返回:

OrderedDict([('submodel1', Linear(in_features=3, out_features=4, bias=True))])

另一种查看子模块方法:

for name, submodel in net.named_modules():print(name, submodel)

返回:

 Net((submodel1): Linear(in_features=3, out_features=4, bias=True)
)
submodel1 Linear(in_features=3, out_features=4, bias=True)

nn.Module在实际使用中可能层层嵌套,一个module包含若干个子module,每一个子module又包含了更多的子module。

为方便用户访问各个子module,nn.Module实现了很多方法,如函数children可以查看直接子module,函数module可以查看所有的子module(包括当前module)。

与之相对应的还有函数named_childennamed_modules,其能够在返回module列表的同时返回它们的名字。

3)

net._parameters #查看网络中使用的参数

返回:

OrderedDict([('param1', Parameter containing:tensor([[0.3398, 0.5239, 0.7981],[0.7718, 0.0112, 0.8100],[0.6397, 0.9743, 0.8300]], requires_grad=True))])

另一种查看参数方法:

net.param1 #等价于net._parameters['param1']

返回:

Parameter containing:
tensor([[0.3398, 0.5239, 0.7981],[0.7718, 0.0112, 0.8100],[0.6397, 0.9743, 0.8300]], requires_grad=True)

另一种查看参数方法,上面的方法没办法查看到层中使用的w,b参数,下面的方法可以查看w,b参数:

for name, param in net.named_parameters():print(name, param.size())

返回:

param1 torch.Size([3, 3])
submodel1.weight torch.Size([4, 3])
submodel1.bias torch.Size([4])

4)_buffers

bn = nn.BatchNorm1d(2)
input = t.rand(3,2)
output = bn(input)
bn._buffers #上一次前向传播结果

返回:

OrderedDict([('running_mean', tensor([0.0514, 0.0749])),('running_var', tensor([0.9116, 0.9068])),('num_batches_tracked', tensor(1))])

5)training

input = t.arange(0, 12).float().view(3,4)
model = nn.Dropout()
#在训练阶段,会有一半的值被设置为0
model(input)

返回:

tensor([[ 0.,  0.,  4.,  0.],[ 8.,  0.,  0., 14.],[ 0.,  0.,  0., 22.]])

 

#如果将training设置为False,那么dropout在测试阶段将什么都不做
model.training = False
model(input)

返回:

tensor([[ 0.,  1.,  2.,  3.],[ 4.,  5.,  6.,  7.],[ 8.,  9., 10., 11.]])

对于batchnorm、dropout、instancenorm等在训练和测试阶段行为差距巨大的层,如果在测试时不将其training值设为True,则可能会有很大影响,这在实际使用中要千万注意。

虽然可通过直接设置training属性,来将子module设为train和eval模式,但这种方式较为繁琐,因如果一个模型具有多个dropout层,就需要为每个dropout层指定training属性。

更为推荐的做法是调用model.train()函数,它会将当前module及其子module中的所有training属性都设为True,相应的,model.eval()函数会把training属性都设为False

print(net.training, net.submodel1.training)
net.eval()
net.training, net.submodel1.training

返回:

True True
(False, False)

 

6)register_forward_hook/register_backward_hook:中间变量

这两个函数的功能类似于variable函数的register_hook,可在module前向传播或反向传播时注册钩子。每次前向传播执行结束后会执行钩子函数(hook)。前向传播的钩子函数具有如下形式:hook(module, input, output) -> None,而反向传播则具有如下形式:hook(module, grad_input, grad_output) -> Tensor or None

钩子函数不应修改输入和输出,并且在使用后应及时删除,以避免每次都运行钩子增加运行负载。钩子函数主要用在获取某些中间结果的情景,如中间某一层的输出或某一层的梯度。这些结果本应写在forward函数中,但如果在forward函数中专门加上这些处理,可能会使处理逻辑比较复杂,这时候使用钩子技术就更合适一些。

下面考虑一种场景,有一个预训练好的模型,需要提取模型的某一层(不是最后一层)的输出作为特征进行分类,但又不希望修改其原有的模型定义文件,这时就可以利用钩子函数

下面给出实现的伪代码:

model = VGG()
features = t.Tensor()
def hook(module, input, output):'''把这层的输出拷贝到features中'''features.copy_(output.data)handle = model.layer8.register_forward_hook(hook)
_ = model(input)
# 用完hook后删除
handle.remove()

 

7)__getattr__ / __setattr__
nn.Module
对象在构造函数中的行为看起来有些怪异,如果想要真正掌握其原理,就需要看两个魔法方法__getattr____setattr__

在Python中有两个常用的buildin方法getattrsetattrgetattr(obj, 'attr1')等价于obj.attr,如果getattr函数无法找到所需属性,Python会转而调用obj.__getattr__('attr1')方法,即getattr函数无法找到的交给__getattr__函数处理,没有实现__getattr__或者__getattr__也无法处理的就会raise AttributeError。

setattr(obj, 'name', value)等价于obj.name=value,如果obj对象实现了__setattr__方法,setattr会直接调用obj.__setattr__('name', value),否则调用buildin方法。

总结一下:

  • result = obj.name会调用buildin函数getattr(obj, 'name'),如果该属性找不到,会调用obj.__getattr__('name')
  • obj.name = value会调用buildin函数setattr(obj, 'name', value),如果obj对象实现了__setattr__方法,setattr会直接调用obj.__setattr__('name', value')

nn.Module实现了自定义的__setattr__函数,当执行module.name=value时,会在__setattr__中判断value是否为Parameternn.Module对象,如果是则将这些对象加到_parameters_modules两个字典中,而如果是其它类型的对象,如Variablelistdict等,则调用默认的操作,将这个值保存在__dict__中。

1》

module = nn.Module() #直接使用nn.Module()对象
module.param = nn.Parameter(t.ones(2,2)) #设置参数
module._parameters

返回:

OrderedDict([('param', Parameter containing:tensor([[1., 1.],[1., 1.]], requires_grad=True))])

2》

submodule1 = nn.Linear(2,2)
submodule2 = nn.Linear(2,2)
module_list = [submodule1, submodule2]
#对于list对象,调用buildin函数,保存在__dict__中
module.submodules = module_list #设置module,因为这里使用的是list,所以会存放在__dict__
print('_modules:', module._modules)
print("__dict__['submodules']:", module.__dict__.get('submodules'))

返回:

_modules: OrderedDict()
__dict__['submodules']: [Linear(in_features=2, out_features=2, bias=True), Linear(in_features=2, out_features=2, bias=True)]

3》

module_list = nn.ModuleList(module_list)#将上面的list类型转成nn.Module对象类型
module.submodules = module_list
#判断是否为nn.Module对象类型
print('ModuleList is instance of nn.Module: ', isinstance(module_list, nn.Module))
print('_modules: ', module._modules) #这样值就会存储在这里,而不是__dict__
print("__dict__['submodules']:", module.__dict__.get('submodules'))

返回:

ModuleList is instance of nn.Module:  True
_modules:  OrderedDict([('submodules', ModuleList((0): Linear(in_features=2, out_features=2, bias=True)(1): Linear(in_features=2, out_features=2, bias=True)
))])
__dict__['submodules']: None

4》

_modules_parameters中的item未保存在__dict__中,所以默认的getattr方法无法获取它,因而nn.Module实现了自定义的__getattr__方法,如果默认的getattr无法处理,就调用自定义的__getattr__方法,尝试从_modules_parameters_buffers这三个字典中获取。

 

getattr(module, 'training')#等价于module.training
#如果没有得到值,就会调用module.__getattr__('training')

返回:

True

 

module.attr1 = 2
getattr(module, 'attr1') #返回2

 

getattr(module, 'param')

返回:

Parameter containing:
tensor([[1., 1.],[1., 1.]], requires_grad=True)

 

8)state_dict()/load_state_dict()

在PyTorch中保存模型十分简单,所有的Module对象都具有state_dict()函数,返回当前Module所有的状态数据。将这些状态数据保存后,下次使用模型时即可利用model.load_state_dict()函数将状态加载进来。优化器(optimizer)也有类似的机制,不过一般并不需要保存优化器的运行状态

#保存模型
t.save(net.state_dict(), 'net.pth') #然后就会在本地文件夹中生成一个net.pth文件#加载已经保存的模型
net2 = Net()
net2.load_state_dict(t.load('net.pth'))

 

9)运行在GPU

将Module放在GPU上运行也十分简单,只需两步:

  • model = model.cuda():将模型的所有参数转存到GPU
  • input.cuda():将输入数据也放置到GPU上

至于如何在多个GPU上并行计算,PyTorch也提供了两个函数,可实现简单高效的并行GPU计算

  • nn.parallel.data_parallel(module, inputs, device_ids=None, output_device=None, dim=0, module_kwargs=None)
  • class torch.nn.DataParallel(module, device_ids=None, output_device=None, dim=0)

可见二者的参数十分相似,通过device_ids参数可以指定在哪些GPU上进行优化,output_device指定输出到哪个GPU上。

唯一的不同就在于前者直接利用多GPU并行计算得出结果,而后者则返回一个新的module,能够自动在多GPU上进行并行加速。

 

# method 1
new_net = nn.DataParallel(net, device_ids=[0, 1])
output = new_net(input)# method 2
output = nn.parallel.data_parallel(new_net, input, device_ids=[0, 1])

DataParallel并行的方式,是将输入一个batch的数据均分成多份,分别送到对应的GPU进行计算,各个GPU得到的梯度累加。与Module相关的所有数据也都会以浅复制的方式复制多份,在此需要注意,在module中属性应该是只读的。

 

6.nn和autograd的关系

nn.Module利用的也是autograd技术,其主要工作是实现前向传播。在forward函数中,nn.Module对输入的tensor进行的各种操作,本质上都是用到了autograd技术。这里需要对比autograd.Function和nn.Module之间的区别:

  • autograd.Function利用了Tensor对autograd技术的扩展,为autograd实现了新的运算op,不仅要实现前向传播还要手动实现反向传播
  • nn.Module利用了autograd技术,对nn的功能进行扩展,实现了深度学习中更多的层。只需实现前向传播功能,autograd即会自动实现反向传播
  • nn.functional是一些autograd操作的集合,是经过封装的函数

作为两大类扩充PyTorch接口的方法,我们在实际使用中应该如何选择呢?

如果某一个操作,在autograd中尚未支持,那么只能实现Function接口对应的前向传播和反向传播。如果某些时候利用autograd接口比较复杂,则可以利用Function将多个操作聚合,实现优化,正如第三章所实现的Sigmoid一样,比直接利用autograd低级别的操作要快。而如果只是想在深度学习中增加某一层,使用nn.Module进行封装则更为简单高效。

 

7.小试牛刀:搭建ResNet

Kaiming He的深度残差网络(ResNet)[^7]在深度学习的发展中起到了很重要的作用,ResNet不仅一举拿下了当年CV下多个比赛项目的冠军,更重要的是这一结构解决了训练极深网络时的梯度消失问题。

首先来看看ResNet的网络结构,这里选取的是ResNet的一个变种:ResNet34。

ResNet的网络结构如图4-2所示,可见除了最开始的卷积池化和最后的池化全连接之外,网络中有很多结构相似的单元,这些重复单元的共同点就是有个跨层直连的shortcut。ResNet中将一个跨层直连的单元称为Residual block,其结构如图4-3所示,左边部分是普通的卷积网络结构,右边是直连,但如果输入和输出的通道数不一致,或其步长不为1,那么就需要有一个专门的单元将二者转成一致,使其可以相加。

另外我们可以发现Residual block的大小也是有规律的,在最开始的pool之后有连续的几个一模一样的Residual block单元,这些单元的通道数一样,在这里我们将这几个拥有多个Residual block单元的结构称之为layer,注意和之前讲的layer区分开来,这里的layer是几个层的集合

考虑到Residual block和layer出现了多次,我们可以把它们实现为一个子Module或函数。这里我们将Residual block实现为一个子moduke,而将layer实现为一个函数。下面是实现代码,规律总结如下:

  • 对于模型中的重复部分,实现为子module或用函数生成相应的module make_layer
  • nn.Module和nn.Functional结合使用
  • 尽量使用nn.Seqential

图4-2: ResNet34网络结构图4-3: Residual block 结构图

[^7]: He K, Zhang X, Ren S, et al. Deep residual learning for image recognition[C]//Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2016: 770-778.

from torch import nn
import torch as t
from torch.nn import functional as F

定义网络:

class ResidualBlock(nn.Module):'''
    实现子module: Residual Block'''
    def __init__(self, inchannel, outchannel, stride=1, shortcut=None):super(ResidualBlock, self).__init__()self.left = nn.Sequential(nn.Conv2d(inchannel,outchannel,3,stride, 1,bias=False),nn.BatchNorm2d(outchannel),nn.ReLU(inplace=True),nn.Conv2d(outchannel,outchannel,3,1,1,bias=False),nn.BatchNorm2d(outchannel) )self.right = shortcutdef forward(self, x):out = self.left(x)residual = x if self.right is None else self.right(x)out += residualreturn F.relu(out)class ResNet(nn.Module):'''
    实现主module:ResNet34ResNet34 包含多个layer,每个layer又包含多个residual block用子module来实现residual block,用_make_layer函数来实现layer'''
    def __init__(self, num_classes=1000):super(ResNet, self).__init__()# 前几层图像转换self.pre = nn.Sequential(nn.Conv2d(3, 64, 7, 2, 3, bias=False),nn.BatchNorm2d(64),nn.ReLU(inplace=True),nn.MaxPool2d(3, 2, 1))# 重复的layer,分别有3,46,3个residual blockself.layer1 = self._make_layer( 64, 64, 3)self.layer2 = self._make_layer( 64, 128, 4, stride=2)self.layer3 = self._make_layer( 128, 256, 6, stride=2)self.layer4 = self._make_layer( 256, 512, 3, stride=2)#分类用的全连接self.fc = nn.Linear(512, num_classes)def _make_layer(self,  inchannel, outchannel, block_num, stride=1):'''
        构建layer,包含多个residual block'''
        shortcut = nn.Sequential(nn.Conv2d(inchannel,outchannel,1,stride, bias=False),nn.BatchNorm2d(outchannel))layers = []layers.append(ResidualBlock(inchannel, outchannel, stride, shortcut))for i in range(1, block_num):layers.append(ResidualBlock(outchannel, outchannel))return nn.Sequential(*layers)def forward(self, x):x = self.pre(x)x = self.layer1(x)x = self.layer2(x)x = self.layer3(x)x = self.layer4(x)x = F.avg_pool2d(x, 7)x = x.view(x.size(0), -1)return self.fc(x)

调用:

model = ResNet()
input  = t.randn(1, 3, 224, 224)
o = model(input)

感兴趣的读者可以尝试实现Google的Inception网络结构或ResNet的其它变体,看看如何能够简洁明了地实现它,实现代码尽量控制在80行以内(本例去掉空行和注释总共不超过50行)。

另外,与PyTorch配套的图像工具包torchvision已经实现了深度学习中大多数经典的模型,其中就包括ResNet34,读者可以通过下面两行代码使用:

from torchvision import models
model = models.resnet34()

本例中ResNet34的实现就是参考了torchvision中的实现并做了简化,感兴趣的读者可以阅读相应的源码,比较这里的实现和torchvision中实现的不同。

 

转载于:https://www.cnblogs.com/wanghui-garcia/p/10633458.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/536589.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

地铁售票系统设计思想及部分代码

设计思想&#xff1a;地铁售票系统的关键点在于换乘&#xff0c;所以首先要分为换乘和不换乘两种情况。不换乘比较简单&#xff0c;通过起始站名和终点站名查询他们的num&#xff0c;然后list打包输出到jsp就可以。换乘的话就先要找到两条线路&#xff0c;找到两条线路的交点也…

浏览器拦截跨域请求处理方法(已阻止跨源请求:同源策略禁止读取远程资源)

原文地址&#xff1a;http://my.oschina.net/lichaoqiang/blog/317823 在浏览器请求中&#xff0c;出现跨域访问资源的问题&#xff0c;我们肯定会遇到。如果跨域请求被阻止&#xff0c;有可能导致css、js 、ajax请求、font字体等资源出现无法正常访问的问题。接下来&#xff0…

面向视频的全新AI架构 —— 阿里云智能视觉技术全解

2019独角兽企业重金招聘Python工程师标准>>> 我们都知道&#xff0c;AI技术正在以可见的速度被应用于各行各业&#xff0c;然而绝大部分业务场景想应用AI技术&#xff0c;都需要算法工程师根据自身业务的标注数据&#xff0c;来进行单独训练&#xff0c;才能打磨出合…

【转】利用python的KMeans和PCA包实现聚类算法

转自&#xff1a;https://www.cnblogs.com/yjd_hycf_space/p/7094005.html 题目&#xff1a; 通过给出的驾驶员行为数据&#xff08;trip.csv&#xff09;&#xff0c;对驾驶员不同时段的驾驶类型进行聚类,聚成普通驾驶类型&#xff0c;激进类型和超冷静型3类 。 利用Python的s…

c 语言str.size,C/C++ strlen(str)和str.length()和str.size()的区别

strlen(str)和str.length()和str.size()都可以求字符串长度,返回字符串中字符的长度&#xff0c;不包括‘/0’。其中str.length()和str.size()是同义词&#xff0c;返回同样的值。strlen(str)是用于求字符数组的长度&#xff0c;其参数是char*。#include #include using namesp…

想跑次高频策略?快来看看Numpy处理真格量化tick数据的技巧

使用澎博真格量化时&#xff0c;很多用户希望用numpy处理tick数据&#xff0c;包括tick数据的留存和运算。 这里有一些技巧。 因为tick数据量比较大&#xff0c;为了降低系统的运算负担&#xff0c;我们不应该在内存里保存大量tick数据。 比如我们只想保存过去10个tick。 可以在…

日本显示屏巨头JDI不敌业务压力,宣布接受中方注资...

本次10亿美元的融资金额中&#xff0c;其中7.2亿美元据传来自中国丝绸之路基金。 最初&#xff0c;在液晶领域日本企业一直都占据着主要市场&#xff0c;如夏普、NEC、东芝等。后来随着韩国三星、LG的强势进入&#xff0c;日本企业的生存空间开始被抢占&#xff0c;现如今中国…

c语言中 d 1是啥意思,空开D/C是什么意思?终于有人把它说清楚了!

原标题&#xff1a;空开D/C是什么意思&#xff1f;终于有人把它说清楚了&#xff01;空气开关是每个人家里必用的东西&#xff0c;但是你到五金店一看&#xff0c;大大小小的开关插座多了去&#xff0c;让人眼花缭乱。怎么选呢&#xff1f;空开有各种字母型号&#xff0c;这些字…

微信小程序开发 | 官方问答精选

2019独角兽企业重金招聘Python工程师标准>>> SF问答精选《七》 多组件显示与隐藏如何实现、function中的...SF问答精选《六》canvas不显示问题SF问答精选《五》菜单内容左右联动、生命周期函数SF问答精选《四》eslint 配置使用 co function&#xff1b;apache 反向代…

清北学堂培训2019.4.4

第一次培训&#xff0c;心情有点激动&#xff08;尽管没了清明节&#xff09;&#xff0c;还见到了各地的dalao们&#xff0c;十分开森 Day 1&#xff08;李昊dalao&#xff09; 上午篇 上午呢&#xff0c;主要讲了关于高精&#xff0c;快速幂&#xff0c;膜模意义下的运算&…

swft c 语言 数组,如何在swift中实现数组的深拷贝

在Objective-C中如果想将一个数组赋值给另外一个数组&#xff0c;同时想让两个数组之间相互独立(即改变其中的一个数组&#xff0c;不影响另外的一个)&#xff0c;有很多的办法&#xff0c;比如我们可以直接copy,用类方法创建新数组。这样得到的数组和原来的数组就是两个完全独…

android studio按钮槽函数,AndroidStudio按钮Button退出程序

AndroidStudio 3.1.41.创建一个新的项目&#xff0c;项目名称为Button&#xff0c;界面为activity_button.xml2.打开activity_button.xml3.点击HelloWorld标签&#xff0c;按Delete删除4.左侧组件栏选择Common - Button5.将Button组件拖到界面上&#xff0c;大概中间的位置6.右…

cobbler介绍与部署

cobbler介绍 Cobbler是一个Linux系统安装的服务&#xff0c;可以通过网络启动(PXE)的方式来快速安装、重装物理服务器和虚拟机&#xff0c;同时还可以管理DHCP&#xff0c;DNS等。 Cobbler可以使用命令行方式管理&#xff0c;也提供了基于Web的界面管理工具(cobbler-web)&#…

android手机给iphone越狱,一台ROOT后的安卓手机:可以用来给iOS 13越狱了

iOS 13时代的越狱工具主要包括unc0ver和Checkra1n两款&#xff0c;前者最新的v4.2.1版本已经支持A9到A13设备从除了支持的设备和系统多&#xff0c;unc0ver的一大优势在于可在iOS设备上独立完成越狱操作&#xff0c;Checkra1n则需要借助电脑&#xff0c;包括重启失效后也是如此…

iOS VIPER架构(三)

路由是实现模块间解耦的一个有效工具。如果要进行组件化开发&#xff0c;路由是必不可少的一部分。目前iOS上绝大部分的路由工具都是基于URL匹配的&#xff0c;优缺点都很明显。这篇文章里将会给出一个更加原生和安全的设计&#xff0c;这个设计的特点是&#xff1a; 路由时用p…

android camera滑动,Android怎么实现小米相机底部滑动指示器

Android怎么实现小米相机底部滑动指示器发布时间&#xff1a;2021-04-15 14:39:38来源&#xff1a;亿速云阅读&#xff1a;94作者&#xff1a;小新这篇文章给大家分享的是有关Android怎么实现小米相机底部滑动指示器的内容。小编觉得挺实用的&#xff0c;因此分享给大家做个参考…

Mariadb修改root密码

2019独角兽企业重金招聘Python工程师标准>>> 默认情况下&#xff0c;新安装的 mariadb 的密码为空&#xff0c;在shell终端直接输入 mysql 就能登陆数据库。 如果是刚安装第一次使用&#xff0c;请使用 mysql_secure_installation 命令初始化。 # mysql_secure_inst…

自学html和css,学习HTML和CSS的5大理由

描述人们学习HTML和CSS最常见的原因是开始从事web开发。但并不是只有web开发人员才要学习HTML和CSS的核心技术。作为一个网络用户&#xff0c;你需要你掌握的相关技术很多&#xff0c;但下面有5个你无法拒绝学习HTML和CSS的理由。1、轻松制作卡通动画Web上的动画很多年来都是使…

html 左侧 树形菜单,vue左侧菜单,树形图递归实现代码

学习vue有一段时间了&#xff0c;最近使用vue做了一套后台管理系统&#xff0c;左侧菜单需求是这样的&#xff0c;可以多层&#xff0c;数据由后台传递。也因为自己对官方文档的不熟悉使得自己踩了不少坑&#xff0c;今天写出来和大家一起分享。效果图如下所示&#xff1a;先说…

关于Istio 1.1,你所不知道的细节

本文整理自Istio社区成员Star在 Cloud Native Days China 2019 北京站的现场分享 第1则 主角 Istio Istio作为service mesh领域的明星项目&#xff0c;从2016年发布到现在热度不断攀升。 Istio & Envoy Github Star Growth 官网中Istio1.1的架构图除了数据面的Envoy和控制面…