高明专业网站建设报价,网站建设超市,手机软件制作网站,wordpress怎样显示文章全部列表一、卷积相关
用一个ff的过滤器卷积一个nn的图像#xff0c;假如padding为p#xff0c;步幅为s#xff0c;输出大小则为#xff1a; [n2p−fs1][n2p−fs1][\frac{n2p-f}{s}1][\frac{n2p-f}{s}1][sn2p−f1][sn2p−f1]
[]表示向下取整#xff08;floor) 大部分深度学习…一、卷积相关
用一个f×f的过滤器卷积一个n×n的图像假如padding为p步幅为s输出大小则为
[n2p−fs1]×[n2p−fs1][\frac{n2p-f}{s}1]×[\frac{n2p-f}{s}1][sn2p−f1]×[sn2p−f1]
[]表示向下取整floor) 大部分深度学习的方法对过滤器不做翻转等操作直接相乘更像是互相关但约定俗成叫卷积运算。
二、三维卷积
图片的数字通道数必须和过滤器中的通道数相匹配。 三维卷积相当于一个立方体与所有通道都乘起来然后求和。可以设计滤波器使得其得到单一通道如红色的边缘特征。
卷积核通道数等于输入通道数卷积核个数等于输出通道数。 三、池化层
最大池化 平均池化 四、为什么使用卷积
1.参数共享。 2.稀疏连接。 五、两个重要课后题 六、第一周课后作业
使用Pytorch来实现卷积神经网络然后应用到手势识别中
代码
import h5py
import time
import torch
import numpy as np
import torch.nn as nn
import matplotlib.pyplot as plt#import cnn_utilsdevice torch.device(cuda if torch.cuda.is_available() else cpu)# 加载数据集
def load_dataset():train_dataset h5py.File(datasets/train_signs.h5, r)train_set_x_orig np.array(train_dataset[train_set_x][:]) # your train set featurestrain_set_y_orig np.array(train_dataset[train_set_y][:]) # your train set labelstest_dataset h5py.File(datasets/test_signs.h5, r)test_set_x_orig np.array(test_dataset[test_set_x][:]) # your test set featurestest_set_y_orig np.array(test_dataset[test_set_y][:]) # your test set labelsclasses np.array(test_dataset[list_classes][:]) # the list of classestrain_set_y_orig train_set_y_orig.reshape((train_set_y_orig.shape[0], 1))test_set_y_orig test_set_y_orig.reshape((test_set_y_orig.shape[0], 1))return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classesX_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes load_dataset()print(X_train_orig.shape) # (1080, 64, 64, 3),训练集1080张图像大小是64*64
print(Y_train_orig.shape) # (1080, 1)
print(X_test_orig.shape) # (120, 64, 64, 3)测试集120张
print(Y_test_orig.shape) # (120, 1)
print(classes.shape) # (6,) 一共6种类别012345index 6
plt.imshow(X_train_orig[index])
print (y str(np.squeeze(Y_train_orig[index,:])))
plt.show()# 把尺寸(H x W x C)转为(C x H x W) 即通道在最前面归一化数据集
X_train np.transpose(X_train_orig, (0, 3, 1, 2))/255 # 将维度转为(1080, 3, 64, 64)
X_test np.transpose(X_test_orig, (0, 3, 1, 2))/255 # 将维度转为(120, 3, 64, 64)
Y_train Y_train_orig
Y_test Y_test_orig# 转成Tensor方便后面的训练
X_train torch.tensor(X_train, dtypetorch.float)
X_test torch.tensor(X_test, dtypetorch.float)
Y_train torch.tensor(Y_train, dtypetorch.float)
Y_test torch.tensor(Y_test, dtypetorch.float)print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape)# 使用交叉熵损失函数不用转化为独热编码
# LeNet模型
class ConvNet(nn.Module):def __init__(self):super(ConvNet, self).__init__()self.conv nn.Sequential(nn.Conv2d(in_channels3, out_channels8, kernel_size4, padding1, stride1), # in_channels, out_channels, kernel_size 二维卷积nn.ReLU(),nn.MaxPool2d(kernel_size8, stride8, padding4), # kernel_size2, stride2原函数就是kernel_size, stride, padding的顺序nn.Conv2d(8, 16, 2, 1, 1),nn.ReLU(),nn.MaxPool2d(kernel_size4, stride4, padding2))self.fc nn.Sequential(nn.Linear(16*3*3, 6), # 16*3*3 向量长度为通道、高和宽的乘积nn.Softmax(dim1))def forward(self, img):feature self.conv(img)output self.fc(feature.reshape(img.shape[0], -1)) # 全连接层块会将小批量中每个样本变平return outputnet ConvNet()
print(net)# 定义损失函数
loss nn.CrossEntropyLoss()# 训练模型
def model(net, X_train, Y_train, device, lr0.001, batch_size32, num_epochs1500, print_lossTrue, is_plotTrue):net net.to(device)print(training on , device)# 定义优化器optimizer torch.optim.Adam(net.parameters(), lrlr, betas(0.9, 0.999))# 将训练数据的特征和标签组合dataset torch.utils.data.TensorDataset(X_train, Y_train)train_iter torch.utils.data.DataLoader(dataset, batch_size, shuffleTrue)train_l_list, train_acc_list [], []for epoch in range(num_epochs):train_l_sum, train_acc_sum, n 0.0, 0.0, 0for X, y in train_iter:X X.to(device)y y.to(device)y_hat net(X)y y.squeeze(1).long() # .squeeze()用来将[batch_size,1]降维至[batch_size],.long用来将floatTensor转化为LongTensorloss函数对类型有要求l loss(y_hat, y).sum()# print(y.shape,y_hat.shape)# print(l)# 梯度清零optimizer.zero_grad()l.backward()optimizer.step()train_l_sum l.item()train_acc_sum (y_hat.argmax(dim1) y).sum().item()# print(y_hat.argmax(dim1).shape,y.shape)n y.shape[0]train_l_list.append(train_l_sum / n)train_acc_list.append(train_acc_sum / n)if print_loss and ((epoch 1) % 10 0):print(epoch %d, loss %.4f, train acc %.3f % (epoch 1, train_l_sum / n, train_acc_sum / n))# 画图展示if is_plot:epochs_list range(1, num_epochs 1)plt.subplot(211)plt.plot(epochs_list, train_acc_list, labeltrain acc, colorr)plt.title(Train acc)plt.xlabel(Epochs)plt.ylabel(Acc)plt.tight_layout()plt.legend()plt.subplot(212)plt.plot(epochs_list, train_l_list, labeltrain loss, colorb)plt.title(Train loss)plt.xlabel(Epochs)plt.ylabel(Loss)plt.tight_layout()plt.legend()plt.show()return train_l_list, train_acc_list#开始时间
start_time time.clock()
#开始训练
train_l_list, train_acc_list model(net, X_train, Y_train, device, lr0.0009, batch_size64, num_epochs500, print_lossTrue, is_plotTrue)
#结束时间
end_time time.clock()
#计算时差
print(CPU的执行时间 str(end_time - start_time) 秒 )#计算分类准确率
def evaluate_accuracy(X_test, Y_test, net, deviceNone):if device is None and isinstance(net, torch.nn.Module):# 如果没指定device就使用net的devicedevice list(net.parameters())[0].device # 未指定的话就是cpuX_test X_test.to(device)Y_test Y_test.to(device)acc (net(X_test).argmax(dim1) Y_test.squeeze()).sum().item()acc acc / X_test.shape[0]return accaccuracy_train evaluate_accuracy(X_train, Y_train, net)
print(训练集的准确率:, accuracy_train)accuracy_test evaluate_accuracy(X_test, Y_test, net)
print(测试集的准确率:, accuracy_test)输出 (1080, 64, 64, 3)
(1080, 1)
(120, 64, 64, 3)
(120, 1)
(6,)
y 2
torch.Size([1080, 3, 64, 64])
torch.Size([120, 3, 64, 64])
torch.Size([1080, 1])
torch.Size([120, 1])
ConvNet((conv): Sequential((0): Conv2d(3, 8, kernel_size(4, 4), stride(1, 1), padding(1, 1))(1): ReLU()(2): MaxPool2d(kernel_size8, stride8, padding4, dilation1, ceil_modeFalse)(3): Conv2d(8, 16, kernel_size(2, 2), stride(1, 1), padding(1, 1))(4): ReLU()(5): MaxPool2d(kernel_size4, stride4, padding2, dilation1, ceil_modeFalse))(fc): Sequential((0): Linear(in_features144, out_features6, biasTrue)(1): Softmax(dim1))
)
training on cuda
epoch 10, loss 0.0274, train acc 0.423
epoch 20, loss 0.0236, train acc 0.580
epoch 30, loss 0.0224, train acc 0.649
epoch 40, loss 0.0218, train acc 0.689
epoch 50, loss 0.0214, train acc 0.713
epoch 60, loss 0.0209, train acc 0.739
epoch 70, loss 0.0206, train acc 0.755
epoch 80, loss 0.0202, train acc 0.786
epoch 90, loss 0.0201, train acc 0.795
epoch 100, loss 0.0197, train acc 0.825
epoch 110, loss 0.0194, train acc 0.839
epoch 120, loss 0.0193, train acc 0.847
epoch 130, loss 0.0191, train acc 0.857
epoch 140, loss 0.0190, train acc 0.860
epoch 150, loss 0.0189, train acc 0.868
epoch 160, loss 0.0188, train acc 0.878
epoch 170, loss 0.0187, train acc 0.886
epoch 180, loss 0.0186, train acc 0.885
epoch 190, loss 0.0185, train acc 0.886
epoch 200, loss 0.0185, train acc 0.890
epoch 210, loss 0.0184, train acc 0.895
epoch 220, loss 0.0184, train acc 0.894
epoch 230, loss 0.0183, train acc 0.900
epoch 240, loss 0.0182, train acc 0.909
epoch 250, loss 0.0182, train acc 0.907
epoch 260, loss 0.0181, train acc 0.914
epoch 270, loss 0.0181, train acc 0.909
epoch 280, loss 0.0180, train acc 0.914
epoch 290, loss 0.0180, train acc 0.916
epoch 300, loss 0.0179, train acc 0.919
epoch 310, loss 0.0179, train acc 0.923
epoch 320, loss 0.0178, train acc 0.924
epoch 330, loss 0.0178, train acc 0.927
epoch 340, loss 0.0178, train acc 0.926
epoch 350, loss 0.0178, train acc 0.925
epoch 360, loss 0.0177, train acc 0.928
epoch 370, loss 0.0177, train acc 0.931
epoch 380, loss 0.0176, train acc 0.931
epoch 390, loss 0.0176, train acc 0.932
epoch 400, loss 0.0176, train acc 0.933
epoch 410, loss 0.0176, train acc 0.933
epoch 420, loss 0.0176, train acc 0.933
epoch 430, loss 0.0176, train acc 0.934
epoch 440, loss 0.0175, train acc 0.934
epoch 450, loss 0.0175, train acc 0.936
epoch 460, loss 0.0175, train acc 0.939
epoch 470, loss 0.0176, train acc 0.938
epoch 480, loss 0.0175, train acc 0.943
epoch 490, loss 0.0174, train acc 0.942
epoch 500, loss 0.0175, train acc 0.941
CPU的执行时间 67.5224961 秒
训练集的准确率: 0.9425925925925925
测试集的准确率: 0.8333333333333334
七、经典网络
LeNet AlexNet VGG-16 八、残差网络 残差网络起作用的主要原因是这些残差块学习恒等函数非常容易能确定网络性能不会受到影响很多时候甚至可以提高效率或者说至少不会降低网络的效率因此创建类似残差网络可以提升网络性能。
九、1×1卷积Network in Network) 这个1x1×32过滤器中的32个数字可以这样理解一个神经元的输入是32个数字输入图片中左下角位置32个通道中的数字即相同高度和宽度上某一切片上的32个数字这32个数字具有不同通道乘以32个权重将过滤器中的32个数理解为权重)然后应用ReLU非线性函数输出相应的结果。 1×1卷积压缩信道数量并减少计算 1x1卷积层就是这样实现了一些重要功能的(doing something pretty non-trivial)它给神经网络添加了一个非线性函数从而减少或保持输入层中的通道数量不变当然如果你愿意也可以增加通道数量。
十、谷歌Inception网络 Inception块里有4条并行的线路。前3条线路使用窗口大小分别是1×1、3×3和5×5的卷积层来抽取不同空间尺寸下的信息其中中间2个线路会对输入先做1×1卷积来减少输入通道数以降低模型复杂度。第四条线路则使用3×3最大池化层后接1×1卷积层来改变通道数。4条线路都使用了合适的填充来使输入与输出的高和宽一致。最后我们将每条线路的输出在通道维上连结并输入接下来的层中去。 十一、迁移学习
如果你有大量数据你应该做的就是用开源的网络和它的权重把这、所有的仪重当作初始化然后训练整个网络。再次注意如果这是一个1000节点的softmax而你只有三个输出你需要你自己的softmax输出层来输出你要的标签。
如果你有越多的标定的数据可以训练越多的层。极端情况下你可以用下载的权重只作为初始化用它们来代替随机初始化接着你可以用梯度下降训练更新网络所有层的所有权重。
十二、第二周重要课后作业 编程作业
参考链接https://blog.csdn.net/u013733326/article/details/80250818
笑脸识别
下一次放假的时候你决定和你的五个朋友一起度过一个星期。这是一个非常好的房子在附近有很多事情要做但最重要的好处是每个人在家里都会感到快乐所以任何想进入房子的人都必须证明他们目前的幸福状态。
作为一个深度学习的专家为了确保“快乐才开门”规则得到严格的应用你将建立一个算法它使用来自前门摄像头的图片来检查这个人是否快乐只有在人高兴的时候门才会打开。 你收集了你的朋友和你自己的照片被前门的摄像头拍了下来。数据集已经标记好了。 代码
import h5py
import time
import torch
import numpy as np
import torch.nn as nn
import matplotlib.pyplot as pltdevice torch.device(cuda if torch.cuda.is_available() else cpu)# 加载数据集
def load_dataset():train_dataset h5py.File(datasets/train_happy.h5, r)train_set_x_orig np.array(train_dataset[train_set_x][:]) # your train set featurestrain_set_y_orig np.array(train_dataset[train_set_y][:]) # your train set labelstest_dataset h5py.File(datasets/test_happy.h5, r)test_set_x_orig np.array(test_dataset[test_set_x][:]) # your test set featurestest_set_y_orig np.array(test_dataset[test_set_y][:]) # your test set labelsclasses np.array(test_dataset[list_classes][:]) # the list of classestrain_set_y_orig train_set_y_orig.reshape((train_set_y_orig.shape[0], 1))test_set_y_orig test_set_y_orig.reshape((test_set_y_orig.shape[0], 1))return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classesX_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes load_dataset()print(X_train_orig.shape) # (600, 64, 64, 3),训练集600张图像大小是64*64
print(Y_train_orig.shape) # (600, 1)
print(X_test_orig.shape) # (150, 64, 64, 3)测试集150张
print(Y_test_orig.shape) # (150, 1)
print(classes.shape) # (2,) 一共2种类别0not happy; 1happyindex 5
plt.imshow(X_train_orig[index])
print (y str(np.squeeze(Y_train_orig[index,:])))
#plt.show()# 把尺寸(H x W x C)转为(C x H x W) 即通道在最前面归一化数据集
X_train np.transpose(X_train_orig, (0, 3, 1, 2))/255 # 将维度转为(600, 3, 64, 64)
X_test np.transpose(X_test_orig, (0, 3, 1, 2))/255 # 将维度转为(150, 3, 64, 64)
Y_train Y_train_orig
Y_test Y_test_orig# 转成Tensor方便后面的训练不然会数据类型报错
X_train torch.tensor(X_train, dtypetorch.float)
X_test torch.tensor(X_test, dtypetorch.float)
Y_train torch.tensor(Y_train, dtypetorch.float)
Y_test torch.tensor(Y_test, dtypetorch.float)print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape)# 构建网络结构包含BN
class ConvNet(nn.Module):def __init__(self):super(ConvNet, self).__init__()self.conv nn.Sequential(nn.Conv2d(in_channels3, out_channels32, kernel_size7, padding3, stride1), # in_channels, out_channels, kernel_size 二维卷积nn.BatchNorm2d(32), # 对输出按通道C批量规范化γ和β可学习nn.ReLU(),nn.MaxPool2d(kernel_size2, stride2), # kernel_size2, stride2原函数就是kernel_size, stride, padding的顺序)self.fc nn.Sequential(nn.Linear(32*32*32, 1), # 16*3*3 向量长度为通道、高和宽的乘积nn.Sigmoid() # S要大写区别于torch.sigmoid())def forward(self, img):feature self.conv(img)output self.fc(feature.reshape(img.shape[0], -1)) # 全连接层块会将小批量中每个样本变平return outputnet ConvNet()
print(net)# 定义损失函数
#loss nn.MSELoss()
loss nn.BCELoss(reduction sum) # 01的交叉损失熵;返回loss的和# 训练模型
def model(net, X_train, Y_train, device, lr0.001, batch_size32, num_epochs1500, print_lossTrue, is_plotTrue):net net.to(device)print(training on , device)# 定义优化器optimizer torch.optim.Adam(net.parameters(), lrlr, betas(0.9, 0.999))# 将训练数据的特征和标签组合dataset torch.utils.data.TensorDataset(X_train, Y_train)train_iter torch.utils.data.DataLoader(dataset, batch_size, shuffleTrue)train_l_list, train_acc_list [], []for epoch in range(num_epochs):train_l_sum, train_acc_sum, n 0.0, 0.0, 0for X, y in train_iter:X X.to(device)y y.to(device)y_hat net(X)#.squeeze(-1)## 交叉熵损失函数中需要 .squeeze()用来将[batch_size,1]降维至[batch_size],.long用来将floatTensor转化为LongTensorloss函数对类型有要求l loss(y_hat, y) #.sum()# print(y.shape,y_hat.shape)# print(l)# 梯度清零optimizer.zero_grad()l.backward()optimizer.step()train_l_sum l.item()train_acc_sum (torch.round(y_hat) y).sum().item()# print(y_hat.argmax(dim1).shape,y.shape)n y.shape[0]train_l_list.append(train_l_sum / n)train_acc_list.append(train_acc_sum / n)if print_loss and ((epoch 1) % 10 0):print(epoch %d, loss %.4f, train acc %.3f % (epoch 1, train_l_sum / n, train_acc_sum / n))# 画图展示if is_plot:epochs_list range(1, num_epochs 1)plt.subplot(211)plt.plot(epochs_list, train_acc_list, labeltrain acc, colorr)plt.title(Train acc)plt.xlabel(Epochs)plt.ylabel(Acc)plt.tight_layout()plt.legend()plt.subplot(212)plt.plot(epochs_list, train_l_list, labeltrain loss, colorb)plt.title(Train loss)plt.xlabel(Epochs)plt.ylabel(Loss)plt.tight_layout()plt.legend()plt.show()return train_l_list, train_acc_list#开始时间
start_time time.clock()
#开始训练
train_l_list, train_acc_list model(net, X_train, Y_train, device, lr0.0009, batch_size64, num_epochs100, print_lossTrue, is_plotTrue)
#结束时间
end_time time.clock()
#计算时差
print(CPU的执行时间 str(end_time - start_time) 秒 )#计算分类准确率
def evaluate_accuracy(X_test, Y_test, net, deviceNone):if device is None and isinstance(net, torch.nn.Module):# 如果没指定device就使用net的devicedevice list(net.parameters())[0].device # 未指定的话就是cpuX_test X_test.to(device)Y_test Y_test.to(device)#print(net(X_test).shape,Y_test.shape)acc (torch.round(net(X_test)) Y_test).sum().item()acc acc / X_test.shape[0]return accaccuracy_train evaluate_accuracy(X_train, Y_train, net)
print(训练集的准确率:, accuracy_train)accuracy_test evaluate_accuracy(X_test, Y_test, net)
print(测试集的准确率:, accuracy_test)结果
D:\Anaconda3\envs\pytorch\python.exe D:/PyCharm files/deep learning/吴恩达/L4W2/L4W2_TRY.py
(600, 64, 64, 3)
(600, 1)
(150, 64, 64, 3)
(150, 1)
(2,)
y 1
torch.Size([600, 3, 64, 64])
torch.Size([150, 3, 64, 64])
torch.Size([600, 1])
torch.Size([150, 1])
ConvNet((conv): Sequential((0): Conv2d(3, 32, kernel_size(7, 7), stride(1, 1), padding(3, 3))(1): BatchNorm2d(32, eps1e-05, momentum0.1, affineTrue, track_running_statsTrue)(2): ReLU()(3): MaxPool2d(kernel_size2, stride2, padding0, dilation1, ceil_modeFalse))(fc): Sequential((0): Linear(in_features32768, out_features1, biasTrue)(1): Sigmoid())
)
training on cuda
epoch 10, loss 0.0950, train acc 0.973
epoch 20, loss 0.0580, train acc 0.982
epoch 30, loss 0.0935, train acc 0.962
epoch 40, loss 0.0150, train acc 0.997
epoch 50, loss 0.0082, train acc 1.000
epoch 60, loss 0.0056, train acc 1.000
epoch 70, loss 0.0073, train acc 1.000
epoch 80, loss 0.0030, train acc 1.000
epoch 90, loss 0.0088, train acc 0.998
epoch 100, loss 0.0024, train acc 1.000
CPU的执行时间 40.573377799999996 秒
训练集的准确率: 1.0
测试集的准确率: 0.98发现跟参考链接一样很快就达到了较高的准确率。
