【深度学习】——pytorch搭建模型及相关模型

目录

1、搭建模型的流程

1)步骤

 2)完整代码——手写minist数据集为例(这里使用的数据集是自带的)

2、搭建模型的四种方法

1)方法一——利用nn.Sequential()

2)方法二——利用collections.orderDict()

3)方法三—— 先创建容器类,然后使用add_module函数向里面添加新模块

4)方法四——利用nn.function中的函数

3、VGG16搭建

4、全卷积层实现方法

5、保存各个子模块的输出特征层



1、搭建模型的流程

1)步骤

1)先清楚需要搭建模型的构造,确定每层的通道数、步长、padding、卷积核大小等

2)创建模型类,将类继承于nn.modules();

class VGG16(nn.Module):def __init__(self,num_classes = 1000):super(VGG16,self).__init__() # 继承父类属性和方法

3)根据模型前向传播的顺序,组建好每一个子模块;一般是用容器nn.Sequential()来存放子模块;一般是放在模型类的__init__()函数当中;

self.conv1 = nn.Sequential(nn.Conv2d(3,64,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)

4)添加forward方法()——上面__init__()方法中只是创建了每一个子模块,每个模块都是独立的,因此在forward函数中主要是根据前向传播的顺序,将各个子模块串起来。

	# 前向传播函数def forward(self,x):# 十三个卷积层x = self.conv1(x)x = self.conv2(x)x = self.conv3(x)x = self.conv4(x)x = self.conv5(x)x = self.conv6(x)x = self.conv7(x)x = self.conv8(x)x = self.conv9(x)x = self.conv10(x)x = self.conv11(x)x = self.conv12(x)x = self.conv13(x)x = self.conv14(x)# 将图像扁平化为一维向量,[1,512,7,7]-->1*512*7*7output = x.view(x.size(0),-1)return output

5)到第4)步模型已经搭建好了,接下来实例化模型后,需要确定损失函数、梯度下降优化算法、学习率更新策略等

# 指定优化器,即梯度下降使用的梯度下降算法,一般有sgd和adam用的多
optimizer = optim.Adam(net.parameters(), lr=0.01)
# 指定学习率优化器,即学习率的变化函数
'''
milestones:分段点
0-75:lr
75-150:gamma*lr
150-:gamma*gamma*lr
'''
scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[75, 150], gamma=0.5)
# 指定损失函数,这里选择的交叉熵损失函数来计算模型的loss
criterion = nn.CrossEntropyLoss()
# print(net)

6)如果数据样本很大,则需要分批次进行训练,即batch

7)训练

8)测试

9)保存模型

 2)完整代码——手写minist数据集为例(这里使用的数据集是自带的)

from collections import OrderedDict  # OrderedDict是字典的子类,可以记住元素的添加顺序
from torch import optim
from torch import nn# 构建模型
class Net(nn.Module):def __init__(self):super(Net, self).__init__()'''一个卷积模块一般有卷积层、激活层、池化层组成一个模型一般由多个卷积模块和多个全连接层组成'''# input shape 28,28,3self.conv1 = nn.Sequential(OrderedDict([('conv1', nn.Conv2d(1, 16, (5, 5), (1, 1), (2, 2))),  # 28,28,16('ReLU1', nn.ReLU()),('pool1', nn.MaxPool2d(2)),  # 14,14,16]))self.conv2 = nn.Sequential(OrderedDict([('conv2', nn.Conv2d(16, 32, (5, 5), (1, 1), (2, 2))),  # 14,14,32('ReLU2', nn.ReLU()),('pool2', nn.MaxPool2d(2)) # 7,7,32]))self.linear = nn.Linear(32 * 7 * 7, 10)def forward(self, x):x = self.conv1(x)x = self.conv2(x)x = x.view(x.size(0), -1) # 将图像扁平化为向量,即shape=【7,7,32】转化为shape=【1,1,7*7*32】output = self.linear(x)return output# 模型实例化后,选择优化器和学习
net = Net()
# 指定优化器,即梯度下降使用的梯度下降算法,一般有sgd和adam用的多
optimizer = optim.Adam(net.parameters(), lr=0.01)
# 指定学习率优化器,即学习率的变化函数
'''
milestones:分段点
0-75:lr
75-150:gamma*lr
150-:gamma*gamma*lr
'''
scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[75, 150], gamma=0.5)
# 指定损失函数,这里选择的交叉熵损失函数来计算模型的loss
criterion = nn.CrossEntropyLoss()
# print(net)# 将数据分成指定大小的批次,然后将数据分批输入后进行训练
def iterate_minibatches(inputs, targets, batch_size, shuffle=True):assert len(inputs) == len(targets)if shuffle:indices = np.arange(len(inputs))np.random.shuffle(indices)start_idx = None# 按照步长为batchsize来计算得到每一个batch的起始样本索引号for start_idx in range(0, len(inputs) - batch_size + 1, batch_size):if shuffle:excerpt = indices[start_idx:start_idx + batch_size]else:excerpt = slice(start_idx, start_idx + batch_size) # 切片# 返回的是一个生成器对象,通过for循环可以取出,并且含有next函数yield inputs[excerpt], targets[excerpt] # 根据索引分割出了一个batch,返回对应的特征集和标签集,一个生成器if start_idx is not None and start_idx + batch_size < len(inputs):excerpt = indices[start_idx + batch_size:] if shuffle else slice(start_idx + batch_size, len(inputs))yield inputs[excerpt], targets[excerpt]# 手写训练过程
# 导入数据
import numpy as np
import torch
from tensorflow.examples.tutorials.mnist import input_datamnist = input_data.read_data_sets("data/MNIST_data/", one_hot=False)
train_data_images = []
train_data_labels = []
test_data_images = []
test_data_labels = []X_train, y_train = mnist.train.images, mnist.train.labels  # 返回的 X_train 是 numpy 下的 多维数组,(55000, 784), (55000,)
X_test, y_test = mnist.test.images, mnist.test.labels  # (10000, 784), (10000,)
X_valid, y_valid = mnist.validation.images, mnist.validation.labels  # (5000, 784),(5000, )train_data_images = np.concatenate((X_train, X_valid), axis=0)  # (60000, 784)
train_data_labels = np.concatenate((y_train, y_valid), axis=0)  # (60000,)
test_data_images = X_test  # (10000, 784)
test_data_labels = y_test  # (10000,)# 变形
train_data_images = np.reshape(train_data_images, [-1, 1, 28, 28])  # (60000, 1, 28, 28)
test_data_images = np.reshape(test_data_images, [-1, 1, 28, 28])  # (10000, 1, 28, 28)# 训练过程
train_loss = 0
train_correct = 0
total = 0
for epoch in range(epochs=100):# iterate_minibatches()对train_data_images, train_data_labels批量划分,shuffle=True,表示乱序# iterate_minibatches()返回的是一个迭代器对象for data, target in iterate_minibatches(train_data_images, train_data_labels, batch_size=8, shuffle=True):optimizer.zero_grad()  # 清除梯度output = net(data)loss = criterion(output, target)  # 计算误差loss.backward() # 后向传播optimizer.step()train_loss += loss.item()  # 计算1个epoch的loss和# 将预测得分最大的类别作为最终的预测类别,元组pred = torch.max(output, 1)  # max函数会返回两个tensor,第一个tensor是每行的最大值;第二个tensor是每行最大值的索引。train_correct += np.sum(pred[1] == target)  # 计算1个epoch的accuracy,这里是通过判断最大预测得分的类别索引和真实标签的索引是否一致,是则表示预测成功total += target.size(0)Train_Accuracy = train_correct / total
Train_Loss = train_loss# 测试过程
test_loss = 0
test_correct = 0
total = 0
for data, target in iterate_minibatches(test_data_images, test_data_labels, batch_size=8, shuffle=True):output = net(data)loss = criterion(output, target)test_loss += loss.item()pred = torch.max(output, 1)test_correct += np.sum(pred[1] == target)total += target.size(0)Test_Accuracy = test_correct / total
Test_Loss = test_loss# 保存模型
model_out_path = "model.pth"
torch.save(net, model_out_path)
print("Checkpoint saved to {}".format(model_out_path))

2、搭建模型的四种方法

1)方法一——利用nn.Sequential()

import torch.nn as nnclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Sequential(  # input shape (1, 28, 28)nn.Conv2d(1, 16, 5, 1, 2),  # output shape (16, 28, 28)nn.ReLU(),nn.MaxPool2d(2),  # output shape (16, 14, 14))self.conv2 = nn.Sequential(nn.Conv2d(16, 32, 5, 1, 2),  # output shape (32, 14, 14)nn.ReLU(),nn.MaxPool2d(2),  # output shape (32, 7, 7))self.linear = nn.Linear(32 * 7 * 7, 10)def forward(self, x):x = self.conv1(x)x = self.conv2(x)x = x.view(x.size(0), -1)output = self.linear(x)return output

2)方法二——利用collections.orderDict()

import torch.nn as nn
from collections import OrderedDict  # OrderedDict是字典的子类,可以记住元素的添加顺序class Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Sequential(OrderedDict([('conv1', nn.Conv2d(1, 16, 5, 1, 2)),('ReLU1', nn.ReLU()),('pool1', nn.MaxPool2d(2)),]))self.conv2 = nn.Sequential(OrderedDict([('conv2', nn.Conv2d(16, 32, 5, 1, 2)),('ReLU2', nn.ReLU()),('pool2', nn.MaxPool2d(2)),]))self.linear = nn.Linear(32 * 7 * 7, 10)def forward(self, x):x = self.conv1(x)x = self.conv2(x)x = x.view(x.size(0), -1)output = self.linear(x)return output

3)方法三—— 先创建容器类,然后使用add_module函数向里面添加新模块

import torch.nn as nnclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Sequential()self.conv1.add_module('conv1', nn.Conv2d(1, 16, 5, 1, 2))self.conv1.add_module('ReLU1', nn.ReLU())self.conv1.add_module('pool1', nn.MaxPool2d(2))self.conv2 = nn.Sequential()self.conv2.add_module('conv2', nn.Conv2d(16, 32, 5, 1, 2))self.conv2.add_module('ReLU2', nn.ReLU())self.conv2.add_module('pool2', nn.MaxPool2d(2))self.linear = nn.Linear(32 * 7 * 7, 10)def forward(self, x):x = self.conv1(x)x = self.conv2(x)x = x.view(x.size(0), -1)output = self.linear(x)return output

4)方法四——利用nn.function中的函数

import torch.nn as nn
import torch.nn.functional as Fclass Net(nn.Module):def __init__(self):super(Net, self).__init__()self.conv1 = nn.Conv2d(1, 16, 5, 1, 2)self.conv2 = nn.Conv2d(16, 32, 5, 1, 2)self.linear = nn.Linear(32 * 7 * 7, 10)def forward(self, x):x = F.max_pool2d(F.relu(self.conv1(x)), 2)x = F.max_pool2d(F.relu(self.conv2(x)), 2)output = self.linear(x)return output

3、VGG16搭建

from torch import nnclass VGG16(nn.Module):def __init__(self,num_classes = 1000):super(VGG16,self).__init__() # 继承父类属性和方法# 根据前向传播的顺序,搭建各个子网络模块## 十三个卷积层,每个卷积模块都有卷积层、激活层和池化层,用nn.Sequential()这个容器将各个模块存放起来# [1,3,224,224]self.conv1 = nn.Sequential(nn.Conv2d(3,64,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,64,224,224]self.conv2 = nn.Sequential(nn.Conv2d(64,64,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算nn.MaxPool2d((2,2),(2,2)))# [1,64,112,112]self.conv3 = nn.Sequential(nn.Conv2d(64,128,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,128,112,112]self.conv4 = nn.Sequential(nn.Conv2d(128,128,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算nn.MaxPool2d((2,2),(2,2)))# [1,128,56,56]self.conv5 = nn.Sequential(nn.Conv2d(128,256,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,256,56,56]self.conv6 = nn.Sequential(nn.Conv2d(256,256,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,256,56,56]self.conv7 = nn.Sequential(nn.Conv2d(256,256,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算nn.MaxPool2d((2,2),(2,2)))# [1,256,28,28]self.conv8 = nn.Sequential(nn.Conv2d(256,512,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True))# [1,512,28,28]self.conv9 = nn.Sequential(nn.Conv2d(512,512,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True))# [1,512,28,28]self.conv10 = nn.Sequential(nn.Conv2d(512,512,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True),nn.MaxPool2d((2,2),(2,2)))# [1,512,14,14]self.conv11 = nn.Sequential(nn.Conv2d(512, 512, (3, 3), (1, 1), (1, 1)),nn.ReLU(inplace=True),)# [1,512,14,14]self.conv12 = nn.Sequential(nn.Conv2d(512, 512, (3, 3), (1, 1), (1, 1)),nn.ReLU(inplace=True),)# [1,512,14,14]-->[1,512,7,7]self.conv13 = nn.Sequential(nn.Conv2d(512, 512, (3, 3), (1, 1), (1, 1)),nn.ReLU(inplace=True),nn.MaxPool2d((2, 2), (2, 2)))# 三个全连接层,每个全连接层之间存在激活层和dropout层self.classfier = nn.Sequential(# [1*512*7*7]nn.Linear(1*512*7*7,4096),nn.ReLU(True),nn.Dropout(),# 4096nn.Linear(4096,4096),nn.ReLU(True),nn.Dropout(),# 4096-->1000nn.Linear(4096,num_classes))# 前向传播函数def forward(self,x):# 十三个卷积层x = self.conv1(x)x = self.conv2(x)x = self.conv3(x)x = self.conv4(x)x = self.conv5(x)x = self.conv6(x)x = self.conv7(x)x = self.conv8(x)x = self.conv9(x)x = self.conv10(x)x = self.conv11(x)x = self.conv12(x)x = self.conv13(x)# 将图像扁平化为一维向量,[1,512,7,7]-->1*512*7*7x = x.view(x.size(0),-1)# 三个全连接层output = self.classfier(x)return output## 测试
import torch
vgg16 = VGG16(21)
print(vgg16)input_ = torch.randn(1,3,224,224)
output = vgg16(input_)
print(output.shape)
print(output)

4、全卷积层实现方法

核心思想:其实就是将全连接层用卷积层去替换了,一般需要经过精心的设计,使得最后输出的是【1,1,channels】的shape。这里以vgg16为例,vgg16最后的特征图大小为【1,512,7,7】,若要变为1,1大小的特征图,则可以使用7,7的卷积核进行卷积,然后利用num_classes个卷积核去进行卷积,最后就得到了特征图【1,num_classes,1,1】,在输出前使用激活函数得到分类得分。

		# 全卷积层self.conv14 = nn.Sequential(nn.Conv2d(512,num_classes,(7,7),(1,1)),nn.ReLU(inplace=True))
from torch import nnclass VGG16(nn.Module):def __init__(self,num_classes = 1000):super(VGG16,self).__init__() # 继承父类属性和方法# 根据前向传播的顺序,搭建各个子网络模块## 十三个卷积层,每个卷积模块都有卷积层、激活层和池化层,用nn.Sequential()这个容器将各个模块存放起来# [1,3,224,224]self.conv1 = nn.Sequential(nn.Conv2d(3,64,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,64,224,224]self.conv2 = nn.Sequential(nn.Conv2d(64,64,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算nn.MaxPool2d((2,2),(2,2)))# [1,64,112,112]self.conv3 = nn.Sequential(nn.Conv2d(64,128,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,128,112,112]self.conv4 = nn.Sequential(nn.Conv2d(128,128,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算nn.MaxPool2d((2,2),(2,2)))# [1,128,56,56]self.conv5 = nn.Sequential(nn.Conv2d(128,256,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,256,56,56]self.conv6 = nn.Sequential(nn.Conv2d(256,256,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算)# [1,256,56,56]self.conv7 = nn.Sequential(nn.Conv2d(256,256,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True), # inplace = True表示是否进行覆盖计算nn.MaxPool2d((2,2),(2,2)))# [1,256,28,28]self.conv8 = nn.Sequential(nn.Conv2d(256,512,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True))# [1,512,28,28]self.conv9 = nn.Sequential(nn.Conv2d(512,512,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True))# [1,512,28,28]self.conv10 = nn.Sequential(nn.Conv2d(512,512,(3,3),(1,1),(1,1)),nn.ReLU(inplace=True),nn.MaxPool2d((2,2),(2,2)))# [1,512,14,14]self.conv11 = nn.Sequential(nn.Conv2d(512, 512, (3, 3), (1, 1), (1, 1)),nn.ReLU(inplace=True),)# [1,512,14,14]self.conv12 = nn.Sequential(nn.Conv2d(512, 512, (3, 3), (1, 1), (1, 1)),nn.ReLU(inplace=True),)# [1,512,14,14]-->[1,512,7,7]self.conv13 = nn.Sequential(nn.Conv2d(512, 512, (3, 3), (1, 1), (1, 1)),nn.ReLU(inplace=True),nn.MaxPool2d((2, 2), (2, 2)))# 全卷积层self.conv14 = nn.Sequential(nn.Conv2d(512,num_classes,(7,7),(1,1)),nn.ReLU(inplace=True))# 前向传播函数def forward(self,x):# 十三个卷积层x = self.conv1(x)x = self.conv2(x)x = self.conv3(x)x = self.conv4(x)x = self.conv5(x)x = self.conv6(x)x = self.conv7(x)x = self.conv8(x)x = self.conv9(x)x = self.conv10(x)x = self.conv11(x)x = self.conv12(x)x = self.conv13(x)x = self.conv14(x)# 将图像扁平化为一维向量,[1,512,7,7]-->1*512*7*7output = x.view(x.size(0),-1)return output## 测试
import torch
vgg16 = VGG16(21)
print(vgg16)input_ = torch.randn(1,3,224,224)
output = vgg16(input_)
print(output.shape)
print(output)

5、保存各个子模块的输出特征层

 在forward函数中,将需要保存的特征层的输出保存在列表中即可,这里以ssd中的为例,其中feathers就是将需要的几个特征图保存了起来,便于后续进行特征图训练,实现多尺度的训练。

    def forward(self, x):features = []for i in range(23):x = self.vgg[i](x)s = self.l2_norm(x)  # Conv4_3 L2 normalizationfeatures.append(s)# apply vgg up to fc7for i in range(23, len(self.vgg)):x = self.vgg[i](x)features.append(x)for k, v in enumerate(self.extras):x = F.relu(v(x), inplace=True)if k % 2 == 1:features.append(x)return tuple(features)

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

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

相关文章

ABB robot 与 Fronius 设备 IO

ABB robot 与 Fronius 设备 IO

初次使用cocoapods注意事项

在仅仅用cocoapods时可能会遇到各种各样的错误和问题 这里中总结下: 1.首先使用cocoapods有非常多优点,在github上非常多优秀的开源项目都用到了它;假设你不会使用它,那么非常多优秀的开源项目你下载下来了也发现跑不起来,假设发现有Profile,Profile.lock,Pods等cocoapods相关…

MongoDB复制集技术

为什么使用MongogDB复制集技术? mysql中:一主一从&#xff0c;一主多从结构存在的问题 1、 fileover&#xff08;故障转移&#xff09;a) 选主投票b) 切换 2、 是否对就用透明化 3、 数据补偿的问题a) 两阶段数据补偿 4、 解决方法 mysql中使用MHAVIP b…

Linux文件系统的实现 (图文并茂,比较好)

作者&#xff1a;Vamei 出处&#xff1a;http://www.cnblogs.com/vamei 欢迎转载&#xff0c;也请保留这段声明。谢谢&#xff01; Linux文件管理从用户的层面介绍了Linux管理文件的方式。Linux有一个树状结构来组织文件。树的顶端为根目录(/)&#xff0c;节点为目录&#xff0…

【深度学习】——如何处理输入图像大小不一样的情况

这里一般有常见的几种方法&#xff1a; 1&#xff09;将图像缩放成大小一致后再输入&#xff0c;如RCNN算法 2&#xff09;roi pooling&#xff1a;这里允许输入图像的大小不一样&#xff0c;后续根据指定的固定大小来求解池化的核大小&#xff0c;以此来得到相同大小的特征图&…

ROS探索总结(一)——ROS简介

随着机器人领域的快速发展和复杂化&#xff0c;代码的复用性和模块化的需求原来越强烈&#xff0c;而已有的开源机器人系统又不能很好的适应需求。2010年Willow Garage公司发布了开源机器人操作系统ROS&#xff08;robot operating system&#xff09;&#xff0c;很快在机器人…

微信浏览器取消缓存的方法

摘要:做微信公家号以及调试手机页面的时辰&#xff0c;防止不了页面要跳转到微信阅读器打开&#xff0c;调试阶段&#xff0c;android版微信阅读器一直都默许缓存html静态资本&#xff0c;每一次静态资本变革乃至新内容发布的时辰在微信阅读器上都极有可能不克不及更新&#xf…

【机器视觉】——裂纹检测笔记

目录 传统算法处理裂缝的基本思路&#xff1a; 第一种思路 第二种思路&#xff1a; 第三种思路 CPP代码 halcon代码 python代码 Matlab代码 深度学习缺陷检测 裂缝检测文献 传统算法处理裂缝的基本思路&#xff1a; 第一种思路 1.先转换彩色图为灰度图 2.进行自适应…

利用union判断系统的大小端

int checkCPUendian()//返回1&#xff0c;为小端&#xff1b;反之&#xff0c;为大端&#xff1b; { union{ unsigned int a; unsigned char b; }c; c.a 1; return 1 c.b; }大端模式(Big-endian)&#xff0c;是指数据的高字节保存在内存的低地址中&#xff0c;而数据…

Filter(过滤器) 和 interceptor(拦截器)的区别

Filter&#xff08;过滤器&#xff09; 和 interceptor&#xff08;拦截器&#xff09;的区别 1.拦截器是基于java反射机制的&#xff0c;而过滤器是基于函数回调的。 2.过滤器依赖于Servlet容器&#xff0c;而拦截器不依赖于Servlet容器。 3.拦截器只对Action请求起作用&#…

ROS探索总结(二)——ROS总体框架

一、 总体结构 根据ROS系统代码的维护者和分布来标示&#xff0c;主要有两大部分&#xff1a;&#xff08;1&#xff09;main&#xff1a;核心部分&#xff0c;主要由Willow Garage公司和一些开发者设计、提供以及维护。它提供了一些分布式计算的基本工具&#xff0c;以及整个…

python 阿狸的进阶之路(4)

装饰器 #1、开放封闭原则&#xff1a;对扩展开放&#xff0c;对修改是封闭#2、装饰器&#xff1a;装饰它人的&#xff0c;器指的是任意可调用对象&#xff0c;现在的场景装饰器-》函数&#xff0c;被装饰的对象也是-》函数#原则&#xff1a;1、不修改被装饰对象的源代码 2、不修…

【深度学习】——利用pytorch搭建一个完整的深度学习项目(构建模型、加载数据集、参数配置、训练、模型保存、预测)

目录 一、深度学习项目的基本构成 二、实战&#xff08;猫狗分类&#xff09; 1、数据集下载 2、dataset.py文件 3、model.py 4、config.py 5、predict.py 一、深度学习项目的基本构成 一个深度学习模型一般包含以下几个文件&#xff1a; datasets文件夹&#xff1a;存放…

二叉树的序遍历

时间限制: 1 s空间限制: 32000 KB题目等级 : 白银 Silver题目描述 Description求一棵二叉树的前序遍历&#xff0c;中序遍历和后序遍历 输入描述 Input Description第一行一个整数n&#xff0c;表示这棵树的节点个数。 接下来n行每行2个整数L和R。第i行的两个整数Li和Ri代表编号…

GUI登录界面

在这次的作业中&#xff0c;我先使用单选按钮&#xff0c;输入框&#xff0c;复选框设计了一个简单地登录界面。接着我使用了MouseListener将登陆按钮与下一个“查询界面”连接起来。最后我使用了我们本周所学的JFrame框架与事件处理机制设计了一个简单地界面。我所设计的登录界…

浅谈ROS操作系统及其应用趋势

ROS操作系统是最先由斯坦福开发的开源机器人操作系统&#xff0c;目前由willowgarage公司开发和维护&#xff0c;相关的开发社区也很成熟&#xff08; http://www.ros.org &#xff0c; http://answers.ros.org, http://www.willowgarage.com), 经过几年的发展API也逐渐稳定&a…

Raft学习传送门

Raft官网 官方可视化动画1 官方可视化动画2 论文中文翻译 论文英文地址 Paxos Made Simple论文翻译 Raft理解 技术分享 《分布式一致性raft算法实现原理》 状态机 MIT&#xff1a; raft实现 分布式系统学习2-Raft算法分析与实现 分布式系统MIT 6.824学习资源 知乎大神的&#…

【Python生成器与迭代器的区别】

目录 一、迭代 二、迭代器 1&#xff09;创建迭代器——两种方法 iter&#xff08;&#xff09;方法 利用()和range结合使用 2&#xff09;具体案例 3、生成器 4、二者的异同 1&#xff09;、共同点 2&#xff09;、不同点 a、语法上 b、用法上 一、迭代 首先理解一…

BZOJ4426 : [Nwerc2015]Better Productivity最大生产率

如果一个区间包含另一个区间&#xff0c;那么这两个区间是否在一起的生产率是一样的。 将所有这种包含了其他区间的区间放入数组$b$&#xff0c;其余的放入数组$c$&#xff0c;有多个相同的时候则从$b$移一个到$c$。 那么$c$里所有区间左端点递增&#xff0c;右端点也递增&…

[codevs1105][COJ0183][NOIP2005]过河

[codevs1105][COJ0183][NOIP2005]过河 试题描述 在河上有一座独木桥&#xff0c;一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子&#xff0c;青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数&#xff0c;我们可以把独木桥上青蛙可能到达的…