精华内容
下载资源
问答
  • 忘了说,今天补上,这个是Paddlepaddle1.8版本,现在早就过渡到2.0了,以下操作可能已被废弃 以下代码摘自Paddle的一份官方教程,大家要多多支持国产框架 paddlepaddle 出处大家搜一搜这里 :...直接上例子,通过简单...

    忘了说,今天补上,这个是Paddlepaddle1.8版本,现在早就过渡到2.0了,以下操作可能已被废弃

    以下代码摘自Paddle的一份官方教程,大家要多多支持国产框架 paddlepaddle
    出处大家搜一搜这里 :https://www.paddlepaddle.org.cn/


    paddle.fluid.initializer中有个NumpyArrayInitializer
    多说无益,直接上例子,通过简单算子求边界:

    大家跑一下就明白了

    import matplotlib.pyplot as plt
    
    import numpy as np
    import paddle
    import paddle.fluid as fluid
    from paddle.fluid.dygraph import Conv2D
    from paddle.fluid.initializer import NumpyArrayInitializer
    %matplotlib inline
    
    with fluid.dygraph.guard():
        # 创建初始化权重参数w
        w = np.array([1, 0, -1], dtype='float32')
        # 将权重参数调整成维度为[cout, cin, kh, kw]的四维张量
        w = w.reshape([1, 1, 1, 3])
        # 创建卷积算子,设置输出通道数,卷积核大小,和初始化权重参数
        # filter_size = [1, 3]表示kh = 1, kw=3
        # 创建卷积算子的时候,通过参数属性param_attr,指定参数初始化方式
        # 这里的初始化方式时,从numpy.ndarray初始化卷积参数
        conv = Conv2D(num_channels=1, num_filters=1, filter_size=[1, 3],
                param_attr=fluid.ParamAttr(
                  initializer=NumpyArrayInitializer(value=w)))
        
        # 创建输入图片,图片左边的像素点取值为1,右边的像素点取值为0
        img = np.ones([50,50], dtype='float32')
        img[:, 30:] = 0.
        # 将图片形状调整为[N, C, H, W]的形式
        x = img.reshape([1,1,50,50])
        # 将numpy.ndarray转化成paddle中的tensor
        x = fluid.dygraph.to_variable(x)
        # 使用卷积算子作用在输入图片上
        y = conv(x)
        # 将输出tensor转化为numpy.ndarray
        out = y.numpy()
    
    f = plt.subplot(121)
    f.set_title('input image', fontsize=15)
    plt.imshow(img, cmap='gray')
    
    f = plt.subplot(122)
    f.set_title('output featuremap', fontsize=15)
    # 卷积算子Conv2D输出数据形状为[N, C, H, W]形式
    # 此处N, C=1,输出数据形状为[1, 1, H, W],是4维数组
    # 但是画图函数plt.imshow画灰度图时,只接受2维数组
    # 通过numpy.squeeze函数将大小为1的维度消除
    plt.imshow(out.squeeze(), cmap='gray')
    plt.show()
    

    在这里插入图片描述

    展开全文
  • 今天小编就为大家分享一篇pytorch 自定义卷积核进行卷积操作方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • pytorch 自定义卷积核进行卷积操作

    万次阅读 多人点赞 2018-11-16 02:43:36
    卷积操作:在pytorch搭建起网络时,大家通常都使用已有的框架进行训练,在网络中使用最多就是卷积操作,最熟悉不过的就是 torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, ...

    一 卷积操作:在pytorch搭建起网络时,大家通常都使用已有的框架进行训练,在网络中使用最多就是卷积操作,最熟悉不过的就是

    torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

    通过上面的输入发现想自定义自己的卷积核,比如高斯核,发现是行不通的,因为上面的参数里面只有卷积核尺寸,而权值weight是通过梯度一直更新的,是不确定的。

    二  需要自己定义卷积核的目的:目前是需要通过一个VGG网络提取特征特后需要对其进行高斯卷积,卷积后再继续输入到网络中训练。

    三 解决方案。使用

    torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

     

    这里注意下weight的参数。与nn.Conv2d的参数不一样

    可以发现F.conv2d可以直接输入卷积的权值weight,也就是卷积核。那么接下来就要首先生成一个高斯权重了。这里不直接一步步写了,直接输入就行。

    kernel = [[0.03797616, 0.044863533, 0.03797616],
             [0.044863533, 0.053, 0.044863533],
             [0.03797616, 0.044863533, 0.03797616]]

    四 完整代码

    class GaussianBlur(nn.Module):
        def __init__(self):
            super(GaussianBlur, self).__init__()
            kernel = [[0.03797616, 0.044863533, 0.03797616],
                      [0.044863533, 0.053, 0.044863533],
                      [0.03797616, 0.044863533, 0.03797616]]
            kernel = torch.FloatTensor(kernel).unsqueeze(0).unsqueeze(0)
            self.weight = nn.Parameter(data=kernel, requires_grad=False)
    
        def forward(self, x):
            x1 = x[:, 0]
            x2 = x[:, 1]
            x3 = x[:, 2]
            x1 = F.conv2d(x1.unsqueeze(1), self.weight, padding=2)
            x2 = F.conv2d(x2.unsqueeze(1), self.weight, padding=2)
            x3 = F.conv2d(x3.unsqueeze(1), self.weight, padding=2)
            x = torch.cat([x1, x2, x3], dim=1)
            return x
    

     这里为了网络模型需要写成了一个类,这里假设输入的x也就是经过网络提取后的三通道特征图(当然不一定是三通道可以是任意通道)

    如果是任意通道的话,使用torch.expand()向输入的维度前面进行扩充。如下:

        def blur(self, tensor_image):
            kernel = [[0.03797616, 0.044863533, 0.03797616],
                   [0.044863533, 0.053, 0.044863533],
                   [0.03797616, 0.044863533, 0.03797616]]
           
            min_batch=tensor_image.size()[0]
            channels=tensor_image.size()[1]
            out_channel=channels
            kernel = torch.FloatTensor(kernel).expand(out_channel,channels,3,3)
            self.weight = nn.Parameter(data=kernel, requires_grad=False)
    
            return F.conv2d(tensor_image,self.weight,1,1)

     

    展开全文
  • 一段对图像进行卷积的程序代码自定义卷积和,可自定义区域处理方法进行卷积操作自定义卷积和。
  • 有时候我们希望对神经网络得到的张量进行特定的卷积操作,如求梯度,求边缘等。 或者,有时我们希望把图像进行预处理操作后输入神经网络,而这个预处理可以用卷积操作实现,如求梯度或高斯滤波。我们希望这个卷积...

    镜像问题:tensorflow 卷积:设定特定卷积核

    动机:

    有时候我们希望对神经网络得到的张量进行特定的卷积操作,如求梯度,求边缘等。

    或者,有时我们希望把图像进行预处理操作后输入神经网络,而这个预处理可以用卷积操作实现,如求梯度或高斯滤波。我们希望这个卷积操作在GPU上执行,这样可以加快运行速度。

    这就需要我们在pytorch中进行自定义的卷积核卷积。

    困难:

    在常用的pytorch的卷积操作中,只有卷积核的尺寸和通道信息,且定义的卷积核是可训练的变量,无法实现卷积核订制,且保持不变

    torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

    解决方法:

    幸运的是,torch.nn.functional.conv2d 可以实现卷积核订制。

    torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

    该函数的参数如下:

    • input – input tensor of shape (minibatch,in_channels,iH,iW) # [N,C,H,W]

    • weight – filters of shape(out_channels,in_channels​,kH,kW) # [C_out,C_in,kH,kW]

    • bias – optional bias tensor of shape (out_channels) . Default: None

    • stride – the stride of the convolving kernel. Can be a single number or a tuple (sH, sW). Default: 1

    • padding – implicit paddings on both sides of the input. Can be a single number or a tuple (padH, padW). Default: 0

    • dilation – the spacing between kernel elements. Can be a single number or a tuple (dH, dW). Default: 1

    • groups – split input into groups, \text{in\_channels}in_channels should be divisible by the number of groups. Default: 1

     

    注意事项:

    torch.nn.functional.conv2d中,input.shape=[B,C,H,W],卷积核weight.shape=[out_channels,in_channels,h,w]。这与tensorflow中的习惯不同。

    如果输入的数据的shape=[B,C,H,W],可使用 tensor.permute()操作进行张量维度的重新排列。

    应用示例:

    import cv2
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    import numpy as np
    import matplotlib.pyplot as plt
    
    def gradient_blur_bhwc(input_bhwc):
    	"""
    	:param     input_bhwc: shape=[B,H,W,C]
    	:return:   grad_x_bhwc: x方向梯度图,shape = [B,H,W-1,1]
    		       grad_y_bhwc:y方向梯度图,shape = [B,H-1,W,1]
    	"""
    	in_channel = input_bhwc.size()[-1]
    	input_bchw = input_bhwc.permute(0,3,1,2)
    
    	filter_x = torch.tensor([[[[-1., 1.]]] * in_channel], dtype=torch.float32)  # [outchannel,in_channel,h,w]=>[1,3,1,2]
    	filter_y = torch.tensor([[[[-1.], [1.]]] * in_channel],dtype=torch.float32)  # [outchannel,in_channel,h,w]=>[1,3,2,1]
    	
    	grad_x_bhwc = F.conv2d(input_bchw, weight=filter_x, stride=1).permute(0,2,3,1)
    	grad_y_bhwc = F.conv2d(input_bchw, weight=filter_y, stride=1).permute(0,2,3,1)
    	
    	return grad_x_bhwc,grad_y_bhwc
    
    
    def gradient_blur_bchw(input_bchw):
    	"""
    	:param      input_bchw: shape=[B,C,H,W]
    	:return:	grad_x_bchw: x方向梯度图,shape = [B,1,H,W-1]
    		        grad_y_bchw:y方向梯度图,shape = [B,1,H-1,W]
    	"""
    	in_channel = input_bchw.size()[1]
    	
    	filter_x = torch.tensor([[[[-1., 1.]]] * in_channel], dtype=torch.float32)  # [outchannel,in_channel,h,w]=>[1,3,1,2]
    	filter_y = torch.tensor([[[[-1.], [1.]]] * in_channel],dtype=torch.float32)  # [outchannel,in_channel,h,w]=>[1,3,2,1]
    	
    	grad_x_bchw = F.conv2d(input_bchw, weight=filter_x, stride=1)
    	grad_y_bchw = F.conv2d(input_bchw, weight=filter_y, stride=1)
    	
    	return grad_x_bchw, grad_y_bchw
    
    input_bhwc = torch.tensor(np.expand_dims(cv2.imread("001.jpg"),axis=0),dtype=torch.float32) # b,h,w,c
    input_bchw = input_bhwc.permute(0,3,1,2)
    grad_x_bchw, grad_y_bchw = gradient_blur_bchw(input_bchw)
    
    # 可视化
    print(grad_x_bchw.shape,grad_y_bchw.shape)
    plt.figure()
    plt.subplot(131)
    plt.imshow(input_bhwc[0,...]/255.,cmap='gray')
    plt.subplot(132)
    plt.imshow(grad_x_bchw[0,0,...],cmap='gray')
    plt.subplot(133)
    plt.imshow(grad_y_bchw[0,0,...],cmap='gray')
    plt.show()

    参考:pytorch 自定义高斯核进行卷积操作

    展开全文
  • 对图像进行卷积是图像处理的基本操作,最近在研究图像滤波,经常要用到自定义卷积,所以实现了一下 1 #include "opencv2/imgproc/imgproc.hpp" 2 #include "opencv2/highgui/highgui.hpp" 3 4 using ...

    对图像进行卷积是图像处理的基本操作,最近在研究图像滤波,经常要用到自定义卷积,所以实现了一下

     1 #include "opencv2/imgproc/imgproc.hpp"
     2 #include "opencv2/highgui/highgui.hpp"
     3 
     4 using namespace cv;
     5 
     6 Mat get_blur_kernel(int kernel_size);//获得归一化滤波的卷积核
     7 
     8 int main(int argc, char ** argv)
     9 {
    10     Mat src, dst;
    11     Point anchor;
    12     double delta;
    13     int ddepth;
    14     int kernel_size = 5;
    15     // 生成一个掩模核 大小为kernel_size*kernel_size,这里我们用归一化块滤波的卷积核做示例
    16     Mat kernel = get_blur_kernel(kernel_size);
    17     // 载入一张图片
    18     src = imread("a.jpg");
    19     if (!src.data)
    20         return -1;
    21 
    22     // 创建窗口
    23     imshow("before",src);
    24     waitKey(500);
    25     // 初始化滤波器参数
    26     anchor = Point(-1, -1);
    27     delta = 0;
    28     ddepth = -1;
    29     //将核设置好之后,使用函数 filter2D 就可以生成滤波器:
    30     filter2D(src, dst, ddepth, kernel, anchor, delta, BORDER_DEFAULT);
    31 
    32     imshow("after", dst);
    33     waitKey(0);
    34     return 0;
    35 }
    36 
    37 //生成归一化滤波的卷积核,通过对kernel.ptr(i)[j]的操作来进行
    38 Mat get_blur_kernel(int kernel_size)
    39 {
    40     Mat kernel = (Mat_<float>(kernel_size, kernel_size));
    41     for (int i = 0; i < kernel_size; i++)
    42     {
    43         for (int j = 0; j < kernel_size; j++)
    44             kernel.ptr<float>(i)[j] = 1.0 / (kernel_size*kernel_size);
    45     }
    46     return kernel;
    47 }

    卷积核kernel其实也是一个Mat对象,我们可以通过kernel.ptr(i)[j]实现对矩阵元素的直接操作,

    将核设置好之后,使用opencv提供的函数 filter2D 就可以生成滤波器:

    filter2D(src, dst, ddepth, kernel, anchor, delta, BORDER_DEFAULT);
    其中各参数含义如下:

    src : 源图像
    dst : 目标图像
    ddepth : dst 的深度。若为负值(如 - 1 ),则表示其深度与源图像相等。
    kernel : 用来遍历图像的核
    anchor : 核的锚点的相对位置,其中心点默认为(-1, -1) 。
    delta : 在卷积过程中,该值会加到每个像素上。默认情况下,这个值为 0 。
    BORDER_DEFAULT : 这里我们保持其默认值,更多细节将在其他教程中详解

    只需改变卷积核,我们就可以使用类似的方法创造自定义滤波了。

     

    作者: Elliott Zheng

    出处: http://www.cnblogs.com/elliottzheng/p/6616869.htmlp/6664218.html>

    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出, 原文链接 如有问题, 可邮件(elliott.zheng@foxmail.com)咨询.

    转载于:https://www.cnblogs.com/elliottzheng/p/6616869.html

    展开全文
  • opencv自定义卷积

    千次阅读 2019-11-04 19:37:20
    #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" using namespace cv; Mat get_blur_kernel(int ...//获得归一化滤波的卷积核 int main(int argc, char ** argv) { Mat src,...
  • 16 - 自定义卷积算子 和 经典算子 代码 和理解注释: #include<opencv2/opencv.hpp>; using namespace cv; int main(int argc, char* argv) { // 16 - 自定义线性滤波 Mat source1; source1 = imread("F...
  • 版本python3.6 保存图片需要PIL,在 cmd 输入pip install pillow 以下是代码` import numpy as np import matplotlib.image ...对一幅3通道图像的一个尺度的卷积运算 def compute_conv(fm, kernel): [h, w] = fm.sha...
  • 卷积是图像处理中一个操作,是kernel在图像的每个像素上的操作。 Kernel本质上一个固定大小的矩阵数组,其中心点称为锚点(anchor point) 卷积如何工作 把kernel放到像素数组之上,求锚点周围覆盖的像素乘积之和...
  • PyTorch 自定义卷积模板,backward 报错 RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation问题,如题目所述原代码更正方案一更正方案二 问题,如...
  • pytorch自定义高斯卷积核进行卷积

    千次阅读 2020-08-31 10:49:33
    pytorch支持自定义卷积核进行卷积操作,使用 torch.nn.functional.conv2d 下面是我用到的自定义高斯卷积核的代码: class SA_net(nn.Module): def __init__(self): super(SA_net, self).__init__() kernel =...
  • 高斯滤波的用处很多,也有很多现成的包可以被调用,比如opencv里面的cv2.GaussianBlur,一般情况,我们是没必要去造轮子,除非遇到特殊情况,比如我们在使用pytorch的过程中,需要自定义高斯核进行卷积操作,假设,...
  • 使用自定义内核给图像做卷积操作

    千次阅读 2019-04-19 11:32:06
    使用C++、opencv创建自定义内核(卷积核),使用内核给图像做卷积操作 关于图像卷积的原理及知识可参考博客https://www.cnblogs.com/bithuaning/p/6924978.html,说的非常详细。 opencv中的相关API: void ...
  • pytorch 自定义高斯核进行卷积操作

    千次阅读 2020-01-08 20:11:40
    高斯滤波的用处很多,也有很多现成的包可以被调用,比如opencv里面的cv2.GaussianBlur,一般情况,我们是没必要去造轮子,除非遇到特殊情况,比如我们在使用pytorch的过程中,需要自定义高斯核进行卷积操作,假设,...
  • 前面我们介绍的图像卷积处理无论是均值还是高斯都是属于模糊卷积,它们都有一个共同的特点就是模糊之后图像的边缘信息不复存在,受到了破坏。我们今天介绍的滤波方法有能力通过卷积处理实现图像模糊的同时对图像边缘...
  • Value error 或layer 不存在等问题 ValueError: Unknown Layer:LayerName 方法1 (亲测可行!...方法2 (待验证) 在Keras中,如果存在自定义layer或者loss,需要在load_model()中以字典形式指定layer或los...
  • 卷积公式: 卷积的作用:模糊图像、提取边缘、图像增强(锐化)等。 常见卷积核算子:Robert算子,对45度和135度的像素变化敏感。 Sobel算子:分别对水平方向和数值方向的像素变化敏感 拉普拉斯算子:用于...
  • 理解图像卷积操作的意义

    万次阅读 多人点赞 2017-05-16 22:40:04
    数字信号处理中卷积 卷积一词最开始出现在信号与线性系统中,信号与线性系统中讨论的就是信号经过一个线性系统以后发生的变化。由于现实情况中常常是一个信号前一时刻的输出影响着这一时刻的输出,所在一般利用系统...
  • 这里写目录标题1.1 导入类库1.2 图片处理1.3自定义卷积核1.4 模糊化操作1.5 维度转换1.6 图片保存1.7 最终结果展示(原始图片,5×5滤波器处理图片)①原始图片②经过5×5滤波器处理后的图片1.8 总结 1.1 导入类库 /...
  • 卷积神经网络——卷积操作 在上一篇《卷积神经网络简介》里我们介绍了卷积神经网络包含四个主要的操作,其中最重要的就是本文要讲述的“卷积”操作。 对于CNN,卷积操作的主要目的是从输入图像中提取特征。卷积...
  • C++实现卷积操作

    千次阅读 2019-09-03 14:51:04
    卷积操作的C++实现 #include <opencv2/opencv.hpp> #include <opencv2/highgui/highgui.hpp> #include <opencv2/core/core.hpp> using namespace std; using namespace cv; Mat Kernel_test_3_3...
  • 如何对图像进行卷积操作

    千次阅读 2019-06-13 10:27:31
    2、卷积操作:卷积核与原图对应位置相乘再求和;然后将所求和放在被卷积操作的图中心位置。 上图表示一个 8×8 的原图,每个方格代表一个像素点;其中一个包含 X 的方格是一个 5×5 的卷积核,核半径等于 5/2 = 2;...
  • 卷积操作的基础知识

    万次阅读 多人点赞 2019-03-05 17:48:34
    在Tensorflow中该API的功能是进行的是卷积操作,那是如何运行的呢? 卷积操作的目的 卷积操作的目的是提取图像的特征。都提取什么特种呢?根据不同的卷积核、不同的计算方式,会得到不同的特征提取图。 图(1) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,782
精华内容 3,112
关键字:

自定义卷积操作