作业5：卷积

最新推荐文章于 2024-05-17 14:53:34 发布
最新推荐文章于 2024-05-17 14:53:34 发布
阅读量169 收藏
点赞数 1
文章标签： python 深度学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59158839/article/details/127347551
版权

目录

作业1

编程实现

作业2

 一、概念

二、探究不同卷积核的作用

三、编程实现

1.实现灰度图的边缘检测、锐化、模糊。（必做）

2.调整卷积核参数，测试并总结。（必做）

3.使用不同尺寸图片，测试并总结。（必做）

总结

作业1

编程实现

  

1. 图1使用卷积核\begin{pmatrix} 1 & -1 \end{pmatrix}，输出特征图

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

featuremap=torch.tensor([[0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255]])
#确定卷积网络
class Cnet(torch.nn.Module):
    def __init__(self,filter,kshape):
        super(Cnet, self).__init__()
        filter = torch.reshape(filter,kshape)
        self.weight = torch.nn.Parameter(data=filter, requires_grad=False)
    def forward(self, featuremap):
        featuremap = F.conv2d(featuremap,self.weight,stride=1,padding=0)
        return  featuremap
#确定卷积层
filter=torch.tensor([-1,1])
#更改卷积层的形状适应卷积函数
kshape = (1,1,1,2)
#生成模型
model = Cnet(filter=filter,kshape=kshape)
#更改图片的形状适应卷积层
featuremap = torch.reshape(featuremap,(1,1,5,6))
output = model(featuremap)
output = torch.reshape(output,(5,5))
plt.imshow(output,cmap='gray')
plt.show()

2. 图1使用卷积核\begin{pmatrix} 1\\ -1\\ \end{pmatrix}，输出特征图

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

featuremap=torch.tensor([[0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255]])
#确定卷积网络
class Cnet(torch.nn.Module):
    def __init__(self,filter,kshape):
        super(Cnet, self).__init__()
        filter = torch.reshape(filter,kshape)
        self.weight = torch.nn.Parameter(data=filter, requires_grad=False)
    def forward(self, featuremap):
        featuremap = F.conv2d(featuremap,self.weight,stride=1,padding=0)
        return  featuremap
#确定卷积层
filter=torch.tensor([-1,1])
#更改卷积层的形状适应卷积函数
kshape = (1,1,2,1)
#生成模型
model = Cnet(filter=filter,kshape=kshape)
#更改图片的形状适应卷积层
featuremap = torch.reshape(featuremap,(1,1,5,6))
output = model(featuremap)
output = torch.reshape(output,(6,4))
plt.imshow(output,cmap='gray')
plt.show()

3. 图2使用卷积核\begin{pmatrix} 1 & -1 \end{pmatrix}，输出特征图

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

featuremap=torch.tensor([[0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [255,255,255,0,0,0],
                      [255,255,255,0,0,0],
                      [255,255,255,0,0,0]])
#确定卷积网络
class Cnet(torch.nn.Module):
    def __init__(self,filter,kshape):
        super(Cnet, self).__init__()
        filter = torch.reshape(filter,kshape)
        self.weight = torch.nn.Parameter(data=filter, requires_grad=False)
    def forward(self, featuremap):
        featuremap = F.conv2d(featuremap,self.weight,stride=1,padding=0)
        return  featuremap
#确定卷积层
filter=torch.tensor([-1,1])
#更改卷积层的形状适应卷积函数
kshape = (1,1,1,2)
#生成模型
model = Cnet(filter=filter,kshape=kshape)
#更改图片的形状适应卷积层
featuremap = torch.reshape(featuremap,(1,1,6,6))
output = model(featuremap)
output = torch.reshape(output,(6,5))
plt.imshow(output,cmap='gray')
plt.show()

4. 图2使用卷积核\begin{pmatrix} 1\\ -1\\ \end{pmatrix}，输出特征图 

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

featuremap=torch.tensor([[0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [0,0,0,255,255,255],
                      [255,255,255,0,0,0],
                      [255,255,255,0,0,0],
                      [255,255,255,0,0,0]])
#确定卷积网络
class Cnet(torch.nn.Module):
    def __init__(self,filter,kshape):
        super(Cnet, self).__init__()
        filter = torch.reshape(filter,kshape)
        self.weight = torch.nn.Parameter(data=filter, requires_grad=False)
    def forward(self, featuremap):
        featuremap = F.conv2d(featuremap,self.weight,stride=1,padding=0)
        return  featuremap
#确定卷积层
filter=torch.tensor([-1,1])
#更改卷积层的形状适应卷积函数
kshape = (1,1,2,1)
#生成模型
model = Cnet(filter=filter,kshape=kshape)
#更改图片的形状适应卷积层
featuremap = torch.reshape(featuremap,(1,1,6,6))
output = model(featuremap)
output = torch.reshape(output,(5,6))
plt.imshow(output,cmap='gray')
plt.show()

5. 图3使用卷积核\begin{pmatrix} 1 & -1 \end{pmatrix}，\begin{pmatrix} 1\\ -1\\ \end{pmatrix}，\begin{pmatrix} 1 &-1 \\ -1&1 \end{pmatrix} ，输出特征图 

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

featuremap=torch.tensor([[255,255,255,255,255,255,255,255,255],
                      [255,0  ,255,255,255,255,255,0  ,255],
                      [255,255,0  ,255,255,255,0  ,255,255],
                      [255,255,255,0  ,255,0  ,255,255,255],
                      [255,255,255,255,0  ,255,255,255,255],
                      [255,255,255,0  ,255,0  ,255,255,255],
                      [255,255,0  ,255,255,255,0  ,255,255],
                      [255,0  ,255,255,255,255,255,0  ,255],
                      [255,255,255,255,255,255,255,255,255],])
#确定卷积网络
class Cnet(torch.nn.Module):
    def __init__(self,filter,kshape):
        super(Cnet, self).__init__()
        filter = torch.reshape(filter,kshape)
        self.weight = torch.nn.Parameter(data=filter, requires_grad=False)
    def forward(self, featuremap):
        featuremap = F.conv2d(featuremap,self.weight,stride=1,padding=0)
        return  featuremap
#确定卷积层
filter=torch.tensor([-1,1])
#更改卷积层的形状适应卷积函数
kshape = (1,1,1,2)
#生成模型
model = Cnet(filter=filter,kshape=kshape)
#更改图片的形状适应卷积层
featuremap = torch.reshape(featuremap,(1,1,9,9))
output = model(featuremap)
output = torch.reshape(output,(9,8))
plt.imshow(output,cmap='gray')
plt.show()


import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

featuremap=torch.tensor([[255,255,255,255,255,255,255,255,255],
                      [255,0  ,255,255,255,255,255,0  ,255],
                      [255,255,0  ,255,255,255,0  ,255,255],
                      [255,255,255,0  ,255,0  ,255,255,255],
                      [255,255,255,255,0  ,255,255,255,255],
                      [255,255,255,0  ,255,0  ,255,255,255],
                      [255,255,0  ,255,255,255,0  ,255,255],
                      [255,0  ,255,255,255,255,255,0  ,255],
                      [255,255,255,255,255,255,255,255,255],])
#确定卷积网络
class Cnet(torch.nn.Module):
    def __init__(self,filter,kshape):
        super(Cnet, self).__init__()
        filter = torch.reshape(filter,kshape)
        self.weight = torch.nn.Parameter(data=filter, requires_grad=False)
    def forward(self, featuremap):
        featuremap = F.conv2d(featuremap,self.weight,stride=1,padding=0)
        return  featuremap
#确定卷积层
filter=torch.tensor([-1,1])
#更改卷积层的形状适应卷积函数
kshape = (1,1,2,1)
#生成模型
model = Cnet(filter=filter,kshape=kshape)
#更改图片的形状适应卷积层
featuremap = torch.reshape(featuremap,(1,1,9,9))
output = model(featuremap)
output = torch.reshape(output,(8,9))
plt.imshow(output,cmap='gray')
plt.show()

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

featuremap=torch.tensor([[255,255,255,255,255,255,255,255,255],
                      [255,0  ,255,255,255,255,255,0  ,255],
                      [255,255,0  ,255,255,255,0  ,255,255],
                      [255,255,255,0  ,255,0  ,255,255,255],
                      [255,255,255,255,0  ,255,255,255,255],
                      [255,255,255,0  ,255,0  ,255,255,255],
                      [255,255,0  ,255,255,255,0  ,255,255],
                      [255,0  ,255,255,255,255,255,0  ,255],
                      [255,255,255,255,255,255,255,255,255],])
#确定卷积网络
class Cnet(torch.nn.Module):
    def __init__(self,filter,kshape):
        super(Cnet, self).__init__()
        filter = torch.reshape(filter,kshape)
        self.weight = torch.nn.Parameter(data=filter, requires_grad=False)
    def forward(self, featuremap):
        featuremap = F.conv2d(featuremap,self.weight,stride=1,padding=0)
        return  featuremap
#确定卷积层
filter=torch.tensor([[1,-1],
                       [-1,1]])
#更改卷积层的形状适应卷积函数
kshape = (1,1,2,2)
#生成模型
model = Cnet(filter=filter,kshape=kshape)
#更改图片的形状适应卷积层
featuremap = torch.reshape(featuremap,(1,1,9,9))
output = model(featuremap)
output = torch.reshape(output,(8,8))
plt.imshow(output,cmap='gray')
plt.show()

作业2

 一、概念

用自己的语言描述“卷积、卷积核、特征图、特征选择、步长、填充、感受野”。

卷积：

所谓两个函数的卷积，本质上就是先将一个函数翻转，然后进行滑动叠加。

在连续情况下，叠加指的是对两个函数的乘积求积分，在离散情况下就是加权求和，为简单起见就统一称为叠加。整体看来是这么个过程：

翻转——>滑动——>叠加——>滑动——>叠加——>滑动——>叠加.....

多次滑动得到的一系列叠加值，构成了卷积函数。

卷积的“卷”，指的的函数的翻转，从 g(t) 变成 g(-t) 的这个过程；同时，“卷”还有滑动的意味在里面。卷积的“积”，指的是积分/加权求和。

卷积核：也称为过滤器，就是图像处理时，给定输入图像，输入图像中一个小区域中像素加权平均后成为输出图像中的每个对应像素，其中权值由一个函数定义，这个函数称为卷积核。CNN 中的卷积核跟传统的卷积核本质没有什么不同。仍然以图像为例，卷积核依次与输入不同位置的图像块做卷积，得到输出。

特征图：在每个卷积层，数据都是以三维形式存在的。你可以把它看成许多个二维图片叠在一起，其中每一个称为一个feature map。在输入层，如果是灰度图片，那就只有一个feature map；如果是彩色图片，一般就是3个feature map（红绿蓝）。层与层之间会有若干个卷积核（kernel），上一层和每个feature map跟每个卷积核做卷积，都会产生下一层的一个feature map。

特征选择：是指从已有的M个特征(Feature)中选择N个特征使得系统的特定指标最优化，是从原始特征中选择出一些最有效特征以降低数据集维度的过程。CNN中采样层负责特征选择。

步长：即每次运算的时候卷积核移动的量。

填充：在原矩阵边界中添加一些值避免信息损失。

感受野：简单来说就是卷积神经网络中每层的卷积特征图上的像素点在原始图像中映射的区域大小，也就相当于高层的特征图中的像素点受原图多大区域的影响。

如图是三层的神经卷积神经网络，每一层卷积核的kernel_size=3, stride=1，那么最上层特征所对应的感受野就为如图所示紫色区域的7x7。

二、探究不同卷积核的作用

1.锐化

 2.模糊

3. 浮雕：提取边界并调换颜色。

 参考：Image Kernels explained visually (setosa.io)

三、编程实现

1.实现灰度图的边缘检测、锐化、模糊。（必做）

边缘检测：

import numpy as np
import torch
from torch import nn
from torch.autograd import Variable
from PIL import Image
import matplotlib.pyplot as plt

im = Image.open('1.png').convert('L')  # 读入一张灰度图的图片
im = np.array(im, dtype='float32')  # 将其转换为一个矩阵
print(im.shape[0], im.shape[1])
plt.imshow(im.astype('uint8'), cmap='gray')  # 可视化图片
plt.title('原图')
plt.show()

im = torch.from_numpy(im.reshape((1, 1, im.shape[0], im.shape[1])))
conv1 = nn.Conv2d(1, 1, 3, bias=False)  # 定义卷积

sobel_kernel = np.array([[-1, -1, -1],
                         [-1, 8, -1],
                         [-1, -1, -1]], dtype='float32')  # 定义轮廓检测算子
sobel_kernel = sobel_kernel.reshape((1, 1, 3, 3))  # 适配卷积的输入输出
conv1.weight.data = torch.from_numpy(sobel_kernel)  # 给卷积的 kernel 赋值

edge1 = conv1(Variable(im))  # 作用在图片上

x = edge1.data.squeeze().numpy()
print(x.shape)  # 输出大小
 
plt.imshow(x, cmap='gray')
plt.show()

  

锐化：

import matplotlib.pyplot as plt
import numpy as np
import cv2 as cv


# 求卷积运算
def convolution(img_old, kernel):
    img_new = np.zeros(img.shape, dtype=int)
    for i in range(1, img_new.shape[0] - 1):  # 第一列和最后一列不用处理
        for j in range(1, img_new.shape[1] - 1):
            tmp = 0  # 初始化为0,用来求和
            for k in range(-1, 2):
                for l in range(-1, 2):
                    tmp += img_old[i + k][j + l] * kernel[k + 1][l + 1]
            img_new[i][j] = abs(tmp)
    return img_new


plt.rc("font", family='Microsoft YaHei')
img = plt.imread('1.png')  # 读取图片
img = img[:, :, 0]  # 把图片从三通道变为单通道
plt.subplot(241), plt.title("1.原图"), plt.axis('off')
plt.imshow(img, cmap="gray")

#  水平锐化
kernel_horizontal = np.array([[1, 2, 1],
                              [0, 0, 0],
                              [-1, -2, -1]])
img_horizontal = convolution(img, kernel_horizontal)
plt.subplot(242), plt.title("2.水平锐化后"), plt.axis('off')
plt.imshow(img_horizontal, cmap="gray")
# 垂直锐化

kernel_vertical = np.array([[1, 0, -1],
                            [2, 0, -2],
                            [1, 0, -1]])
img_vertical = convolution(img, kernel_vertical)
plt.subplot(243), plt.title("3.垂直锐化后"), plt.axis('off')
plt.imshow(img_vertical, cmap="gray")
plt.show()

模糊：

import cv2
import numpy as np

img = cv2.imread("1.png")
kernel = np.ones((5,5),np.uint8)

imgGray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
imgBlur = cv2.GaussianBlur(imgGray,(7,7),0)

cv2.imshow("Gaussian Blur",imgBlur)
cv2.waitKey(0)

2.调整卷积核参数，测试并总结。（必做）

增加步长为3:

conv1 = nn.Conv2d(1, 1, 3,stride=3, bias=False)  # 定义卷积

可以看出增加步长使图像更加模糊。 

  增加padding为6：

conv1 = nn.Conv2d(1, 1, 3,padding=6, bias=False)  # 定义卷积

3.使用不同尺寸图片，测试并总结。（必做）

原图：

 边缘检测：

锐化：

模糊：

总结

通过本次实验对卷积操作和图像的本质有了更深的理解，在卷积神经网络面前，所有图像都是矩阵，矩阵中就是一个个的像素，这些像素组成了我们肉眼看到的图像。从信号与系统的角度看，卷积很多时候出现在一个系统的单位脉冲响应与输入信号上，用于求出系统在一定输入下所对应的输出。神经网络的多层结构从一开始的设想是模仿生物的神经元的一层一层传递的结构，从一开始的神经元判断角和边等等到大的局部特征最终得到所看到的目标是否是与神经元中记忆的某一个模式所匹配来进行目标的判断。

cdd04
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
人工智能 作业4：CNN - 卷积
m0_52009861的博客
05-10 683
目录概念描述卷积卷积核多通道特征图特征选择不同卷积核的作用和原理编程实现经典卷积核，实现灰度图的边缘检测、锐化、模糊调整经典卷积核参数使用不同尺寸图片探索更多类型卷积核尝试彩色图片边缘检测总结 概念描述 卷积 卷积核 多通道 特征图 特征选择 不同卷积核的作用和原理 编程实现 经典卷积核，实现灰度图的边缘检测、锐化、模糊 调整经典卷积核参数 使用不同尺寸图片 探索更多类型卷积核 尝试彩色图片边缘检测 总结 ...
卷积神经网络——通过案例对原理进行剖析（MNIST识别和狗狗分类）
sjjsaaaa的博客
05-04 2211
卷积神经网络 计算机视觉利器——卷积神经网络。 卷积神经网络，简称为卷积 网络，与普通神经网络的区别是它的卷积层内的神经元只覆盖输入特征局部范围的单元 ，具有稀疏连接和权重共享的特点，而且其中的过滤器可以做到 对图像关键特征的抽取。因为这一特点，卷积神经网络在图像识别方面 能够给出更好的结果。 一、卷积神经网络的结构 看一个通过卷积神经网络识别MNIST图像的例子： 1.导入数据集 import numpy as np # 导入NumPy数学工具箱 import pandas as pd # 导入Panda
NNDL 作业5：卷积
weixin_52086410的博客
10-17 489
本文是对一些根据一些卷积核进行特征提取，并且实现一些卷积核的功能。
深度学习作业：基于卷积神经网络的天气识别
01-04
卷积神经网络（Convolutional Neural Network，简称CNN）是深度学习中的一种重要网络结构，它通过引入卷积层，池化层以及较深的网络层数，实现对图像高层语义特征的感知，提升图像分类效果。本文基于卷积神经网络...
吴恩达改善深层神经网络：卷积神经网络，序列模型作业
09-28
吴恩达改善深层神经网络：卷积神经网络，序列模型作业，因为太大了就放百度云了，不能下请私信我 [email protected]
deeplearning.ai 编程解答：卷积神经网络
02-23
deeplearning.ai 编程解答：卷积神经网络。。。 Andrew Ng/
基于复数的卷积神经网络：复数卷积、复数池化、复数激活函数、复数全连接等python源码(含详细注释).zip
05-16
基于复数的卷积神经网络：复数卷积、复数池化、复数激活函数、复数全连接等python源码(含详细注释).zip个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计...
吴恩达深度学习卷积神经网络第三周作业所需文件yolo.h5
10-30
如果import其他地方找到的yolo.h5可能导致文件不可用，折腾了一下午，终于搞定了这个文件，现在分享出来~
【Python】Python中变量或者函数加下划线‘_‘的含义
yangweipeng708的博客
05-14 678
理解这些约定可以帮助Python开发者编写更清晰、更Pythonic的代码，并理解其他Python代码中的命名习惯。）通常用来指示特定的编程约定或用法，这些约定主要关乎变量和函数的可访问性以及预期的使用范围。在Python中，变量或函数前面加一个下划线（
python3.6.8安装Transformers
筱阳的博客
05-13 796
4.transformers安装。
使用Python操作excel单元格——在单元格中插入公式
xll_007的博客
05-16 350
使用Python操作excel单元格——在单元格中插入公式。 通过使用Python的openpyxl库，来操作excel单元格，在单元格中插入公式的操作。把学习的过程分享给大家。大佬勿喷！
python数据分析——时间序列
qq_74013365的博客
05-14 1996
时间序列是按照时间顺序排列的一系列随时间变化而变化的数据点或观测值。时间序列可以是离散的，例如每月的销售数据，也可以是连续的，例如气温和股票价格等。时间序列常用于预测和分析未来的趋势，例如经济增长、股票走势、天气变化等。时间序列分析是数据分析中的重要部分，它涉及到对随时间变化的数据进行研究，以揭示其内在规律、趋势和周期性变化。Python作为一种强大的编程语言，拥有众多的数据处理和可视化库，如pandasnumpymatplotlib和seaborn等，这些库在处理时间序列数据时表现出色。
【华为OD机试-C卷D卷-200分】 简易内存池【C++/Java/Python】
goldarmour的博客
05-14 164
请实现一个简易内存池,根据请求命令完成内存分配和释放。 内存池支持两种操作命令，REQUEST和RELEASE，其格式为： REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。 RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
python EEL + vue3.js 简单示例
bigcarp的专栏
05-15 186
eel官方示例中暴露的js函数是全局函数，vue中的自定义函数作用域通常都是组件范围内。要让eel.js调用，需要将其升为全局可用。一般方法有 app.config.globalProperties 或 mixin等。
Python slice() 使用方法及示例说明
ym62033的博客
05-15 198
处。
Python代码：七、小数化整数
m0_61834747的博客
05-16 209
日常生活中我们会遇到很多小数，但是有的人不喜欢小数，因此会用四舍五入的方式将其去掉。在Python中我们更加简单，可以利用强制类型转换将小数转变成整数，请你试一试。
泰迪智能科技2024大数据分析/开发/Python数据分析项目班课程大纲
最新发布
tipdm0526的博客
05-17 272
泰迪智能科技2024大数据分析/开发/Python数据分析项目班课程大纲
全国大学生数学建模竞赛【集训营E题】丨 近5年赛题实现，模拟参赛体验
tipdm0526的博客
05-14 150
全国大学生数学建模竞赛【集训营E题】
分析卷积神经网络中用1×1的卷积核的作业？
06-11
在卷积神经网络中，1×1的卷积核通常被用来进行通道数的调整和降维操作。具体来说，1×1卷积核可以对每个通道进行线性变换，并将不同通道之间的信息进行交互和整合。这种操作可以实现对网络中通道数的调整，从而达到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值