精华内容
下载资源
问答
  • pytorch自定义高斯卷积核进行卷积

    千次阅读 2020-08-31 10:49:33
    下面是我用到的自定义高斯卷积核的代码: class SA_net(nn.Module): def __init__(self): super(SA_net, self).__init__() kernel =get_kernel(kernlen=5,nsig=3) #获得高斯卷积核 kernel = torch.FloatTensor...

    pytorch支持自定义卷积核进行卷积操作,使用

    torch.nn.functional.conv2d

    下面是我用到的自定义高斯卷积核的代码:

    
    
    class SA_net(nn.Module):
        def __init__(self):
            super(SA_net, self).__init__()
            kernel =get_kernel(kernlen=5,nsig=3) #获得高斯卷积核
            kernel = torch.FloatTensor(kernel).unsqueeze(0).unsqueeze(0)   #扩展两个维度
            self.weight = nn.Parameter(data=kernel, requires_grad=False)
            self.BN=nn.BatchNorm2d(num_features=1)
     
        def forward(self, x1,x2):   #x1是用来计算attention的,x2是用来计算的Cs
            x1_attention = F.conv2d(x1, self.weight, padding=2)    #bs,i_c,H1,W1---->bs,1,H1,W1
            x1_attention=self.BN(x1_attention)   #bs,1,H1,W1
            x_max=torch.max(x1_attention,x1)     #bs,1,H1,W1
            x_out=x_max*x2    #bs,1,H,W *bs,i_c,H1,W1 =bs,i_c,H_max,W_max (H1和H2取较大的那个)
    
            return x_out
    
    
    def get_kernel(kernlen=16, nsig=3):     # nsig 标准差 ,kernlen=16核尺寸      
        interval = (2*nsig+1.)/kernlen      #计算间隔 
        x = np.linspace(-nsig-interval/2., nsig+interval/2., kernlen+1)   #在前两者之间均匀产生数据
    
                                              #高斯函数其实就是正态分布的密度函数
        kern1d = np.diff(st.norm.cdf(x))      #先积分在求导是为啥?得到一个维度上的高斯函数值
        '''st.norm.cdf(x):计算正态分布累计分布函数指定点的函数值
            累计分布函数:概率分布函数的积分'''
        kernel_raw = np.sqrt(np.outer(kern1d, kern1d))   #np.outer计算外积,再开平方,从1维高斯参数到2维高斯参数
        kernel = kernel_raw/kernel_raw.sum()             #确保均值为1
        return kernel
    
    展开全文
  • 1、二维高斯函数 G(x,y)=12πσ2exp⁡(−x2+y22σ2)G(x,y)=\frac{1}{2\pi {{\sigma }^{2}}}\exp \left( -...2、坐标(以5×5卷积核为例) 3、Matlab实现 sigma1=2; k=5; % kernel大小 pai=3.1415926; kernel=zeros(k);

    1、二维高斯函数
    G ( x , y ) = 1 2 π σ 2 exp ⁡ ( − x 2 + y 2 2 σ 2 ) G(x,y)=\frac{1}{2\pi {{\sigma }^{2}}}\exp \left( -\frac{{{x}^{2}}+{{y}^{2}}}{2{{\sigma }^{2}}} \right) G(x,y)=2πσ21exp(2σ2x2+y2)
    2、坐标 ( x , y ) (x,y) (x,y)(以5×5卷积核为例)
    在这里插入图片描述
    3、Matlab实现

    sigma1=2;
    k=5;    % kernel大小
    pai=3.1415926;
    kernel=zeros(k);
    m=(k+1)/2;
    sigma=2*sigma1*sigma1;
    for i=-1*(k-1)/2:(k-1)/2
       for j=-1*(k-1)/2:(k-1)/2
          kernel(i+m,j+m)=(-1/(pai*sigma))*exp(-1*(i^2+j^2)/(sigma));
       end
    end
    kernel=kernel./sum(kernel,'all')  % 归一化
    

    结果与Matlab函数fspecial()生成的高斯卷积核一致,卷积核如图所示:
    在这里插入图片描述
    4、OpenCV实现

    int main()
    {
    	double sigma = 2, pai = 3.1415926;
    	int k = 5, m = (k + 1) / 2, n = m - 1;	// k-高斯卷积核大小
    	Mat kernel = Mat::zeros(Size(k, k), CV_64FC1);
    	double *p, Ksum;
    	sigma = 2 * sigma * sigma;
    	for (int i = -1 * n; i <= n; i++)
    	{
    		p = kernel.ptr<double>(i + n);
    		for (int j = -1 * n; j <= n; j++)
    		{
    			p[j + n] = (1 / (pai*sigma)) * exp(-1 * (i * i + j * j) / sigma);
    		}
    	}
    	Ksum = sum(kernel).val[0];
    	kernel = kernel.mul(1/Ksum);
    	cout << kernel << endl;
    
    	getchar();
    	return 0;
    }
    
    展开全文
  • 高斯卷积核滤波的实现

    千次阅读 2018-01-10 15:22:24
    http://blog.csdn.net/yangyangyang20092010/article/details/48576007  也对高斯权值做了详细的解释 ...高斯滤波是一种线性平滑滤波,适用于消除高斯噪声,在图像处理的降噪、平滑中应用较多,特

    转载地址  http://blog.csdn.net/dcrmg/article/details/52304446#reply

    http://blog.csdn.net/yangyangyang20092010/article/details/48576007  也对高斯权值做了详细的解释


    高斯滤波是一种线性平滑滤波,适用于消除高斯噪声,在图像处理的降噪、平滑中应用较多,特别是对抑制或消除服从正态分布的噪声非常有效。

    高斯滤波的过程其实就是对整幅图像进行加权平均操作的过程。滤波后图像上每一个像素的灰度值大小,由其本身和邻域内的其他像素共同决定。具体实现是:用一个大小为(2*N+1)的模板(或称卷积核、掩模)依次扫描图像中的每一个像素,用模板确定的邻域内像素的加权平均灰度替代模板中心像素点的灰度值。


    一维、二维高斯分布


    一维高斯函数表述为:



    对应图形:





    二维高斯函数表述为:




    对应图形:




    一些重要特性说明:

    1. 一维二维高斯函数中μ是服从正态分布的随机变量的均值,称为期望或均值影响正态分布的位置,实际的图像处理应用中一般取μ=0;σ是标准差,σ^2是随机变量的方差,σ定义了正态分布数据的离散程度,σ越大,数据分布越分散,σ越小,数据分布越集中。

    在图形或滤波效果上表现为:σ越大,曲线越扁平,高斯滤波器的频带就越宽,平滑程度就越好,σ越小,曲线越瘦高,高斯滤波的频带就越窄,平滑程度也越弱;

    2. 二维高斯函数具有旋转对称性,即滤波器在各个方向上的平滑程度是相同的.一般来说,一幅图像的边缘方向是事先不知道的,因此,在滤波前是无法确定一个方向上比另一方向上需要更多的平滑.旋转对称性意味着高斯平滑滤波器在后续边缘检测中不会偏向任一方向

    3. 高斯函数是单值函数。这表明,高斯滤波器用像素邻域的加权均值来代替该点的像素值,而每一邻域像素点权值是随该点与中心点的距离单调增减的。这一性质是很重要的,因为边缘是一种图像局部特征,如果平滑运算对离算子中心很远的像素点仍然有很大作用,则平滑运算会使图像失真;

    4.  相同条件下,高斯卷积核的尺寸越大,图像的平滑效果越好,表现为图像越模糊,同时图像细节丢失的越多;尺寸越小,平滑效果越弱,图像细节丢失越少;


    以下对比一下不同大小标准差σ(Sigma)对图像平滑的影响:


    原图:



    卷积核尺寸5*5,σ=0.1:



    卷积核尺寸5*5,σ=1:



    对比可以看到,Sigma(σ)越大,平滑效果越明显。


    C++对高斯卷积核参数求解:


    [cpp]  view plain  copy
    1. #include "iostream"  
    2. #include "math.h"  
    3.   
    4. using namespace std;   
    5. using namespace cv;    
    6.   
    7. //******************高斯卷积核生成函数*************************  
    8. //第一个参数gaus是一个指向含有3个double类型数组的指针;  
    9. //第二个参数size是高斯卷积核的尺寸大小;  
    10. //第三个参数sigma是卷积核的标准差  
    11. //*************************************************************  
    12. void GetGaussianKernel(double **gaus, const int size,const double sigma);  
    13.   
    14. int main(int argc,char *argv[])    
    15. {  
    16.     int size=5; //定义卷积核大小  
    17.     double **gaus=new double *[size];  
    18.     for(int i=0;i<size;i++)  
    19.     {  
    20.         gaus[i]=new double[size];  //动态生成矩阵  
    21.     }  
    22.     cout<<"尺寸 = 3*3,Sigma = 1,高斯卷积核参数为:"<<endl;  
    23.     GetGaussianKernel(gaus,3,1); //生成3*3 大小高斯卷积核,Sigma=1;     
    24.     cout<<"尺寸 = 5*5,Sigma = 10,高斯卷积核参数为:"<<endl;  
    25.     GetGaussianKernel(gaus,5,10); //生成5*5 大小高斯卷积核,Sigma=1;    
    26.     system("pause");  
    27.     return 0;  
    28. }  
    29.   
    30. //******************高斯卷积核生成函数*************************  
    31. void GetGaussianKernel(double **gaus, const int size,const double sigma)  
    32. {  
    33.     const double PI=4.0*atan(1.0); //圆周率π赋值  
    34.     int center=size/2;  
    35.     double sum=0;  
    36.     for(int i=0;i<size;i++)  
    37.     {  
    38.         for(int j=0;j<size;j++)  
    39.         {  
    40.             gaus[i][j]=(1/(2*PI*sigma*sigma))*exp(-((i-center)*(i-center)+(j-center)*(j-center))/(2*sigma*sigma));  
    41.             sum+=gaus[i][j];  
    42.         }  
    43.     }  
    44.   
    45.     for(int i=0;i<size;i++)  
    46.     {  
    47.         for(int j=0;j<size;j++)  
    48.         {  
    49.             gaus[i][j]/=sum;  
    50.             cout<<gaus[i][j]<<"  ";  
    51.         }  
    52.         cout<<endl<<endl;  
    53.     }  
    54.     return ;  
    55. }  


    求得的高斯卷积核参数存放在一个大小为N*N的数组内:




    展开全文
  • 正态函数(即一维Gaussian卷积核)如下 二维卷积核通过对一维积分得到,并且μ = 0 根据如下源码可知:sigma根据如下公式推得,其中ksize是卷积尺寸(方阵长或宽) sigma = ((ksize-1)*0.5 – 1)*0...

    贴出getGaussianKernel源码

    在smooth.cpp中

    提示:Gaussian核基于 正态分布函数设计

    μ是均值,σ^2是方差

    正态函数(即一维Gaussian卷积核)如下

    f(x) = \frac{1}{\sqrt{2 \pi } \sigma }exp(-\frac{(x - \mu) ^ 2}{2 \sigma^2})

    二维卷积核通过对一维积分得到,并且μ = 0

    g(x, y) = \frac{1}{2 \pi \sigma ^2}exp(-\frac{x ^ 2 + y ^2}{2 \sigma^2})

    根据如下源码可知:sigma根据如下公式推得,其中ksize是卷积尺寸(方阵长或宽)

    sigma = ((ksize-1)*0.5 – 1)*0.3 + 0.8。

    但是注意的是该源码是在限制尺寸 1~7,设置sigma = 0就是使用如下代码的默认参数。

    static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =  
    	    {  
    	        {1.f},  
    	        {0.25f, 0.5f, 0.25f},  
    	        {0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},  
    	        {0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f}
    	    }; 
    /****************************************************************************************\
                                         Gaussian Blur
    \****************************************************************************************/
    
    cv::Mat cv::getGaussianKernel( int n, double sigma, int ktype )
    {
    	const int SMALL_GAUSSIAN_SIZE = 7;
    	static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =
    	{
    		{1.f},
    		{0.25f, 0.5f, 0.25f},
    		{0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},
    		{0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f}
    	};
    
    	const float* fixed_kernel = n % 2 == 1 && n <= SMALL_GAUSSIAN_SIZE && sigma <= 0 ?
    		small_gaussian_tab[n>>1] : 0;
    
        CV_Assert( ktype == CV_32F || ktype == CV_64F );
        Mat kernel(n, 1, ktype);
        float* cf = kernel.ptr<float>();
        double* cd = kernel.ptr<double>();
    
        double sigmaX = sigma > 0 ? sigma : ((n-1)*0.5 - 1)*0.3 + 0.8;
        double scale2X = -0.5/(sigmaX*sigmaX);
        double sum = 0;
    
        int i;
        for( i = 0; i < n; i++ )
        {
            double x = i - (n-1)*0.5;
            double t = fixed_kernel ? (double)fixed_kernel[i] : std::exp(scale2X*x*x);
            if( ktype == CV_32F )
            {
                cf[i] = (float)t;
                sum += cf[i];
            }
            else
            {
                cd[i] = t;
                sum += cd[i];
            }
        }
    
        sum = 1./sum;
        for( i = 0; i < n; i++ )
        {
            if( ktype == CV_32F )
                cf[i] = (float)(cf[i]*sum);
            else
                cd[i] *= sum;
        }
    
        return kernel;
    }

     贴出代码实现

    #include <opencv2/opencv.hpp>
    using namespace cv;
    int main()
    {
    	Mat g = getGaussianKernel(5, 0);
    	g = g * g.t() * 256 ;//g * g的转置得到二维高斯卷积核 (5*1 * 1*5) = (5*5)
    	std::cout << g << std::endl;
    	system("pause");
        return 0;
    }

    256是原先归一化的系数的倒数

    得到结果 

    其实限制死的参数 是 真正带入sigma运算结果的近似值,只不过在卷积核小的时候影响不大罢了。

    其实高斯卷积核对于视觉领域实在是影响太大了,不得不把源码抠出来深度理解下。不然不知道各个参数是什么意思。对后续opencv知识的学习就更难掌握了。

    展开全文
  • 在跑一份代码时,效果一直提升不上去,偶然将3 * 3的卷积核换成了4 * 4的卷积核,效果奇佳,于是搜索了一下卷积核的大小对网络性能的影响,总结如下: 1.大卷积核和小卷积核 显然,大卷积核的感受野更大,自然提取...
  • 高斯卷积核如何生成 C语言实现

    千次阅读 2017-12-07 20:30:37
    对于学图像专业的人来说,对图像进行高斯滤波应该不会陌生,本质上就是将图像...matlab中有函数能自动生成高斯卷积核:  gs=fspecial('gaussian',3,1)  gs =  0.0751 0.1238 0.0751  0.1238 0.2042 0.1238
  • 高斯滤波及高斯卷积核C++实现

    万次阅读 多人点赞 2016-08-24 23:59:01
    高斯滤波是一种线性平滑滤波,适用于消除高斯噪声,在图像处理...具体实现是:用一个大小为(2*N+1)的模板(或称卷积核、掩模)依次扫描图像中的每一个像素,用模板确定的邻域内像素的加权平均灰度替代模板中心像素...
  • 高斯卷积核是什么还有为什么它是实现尺度变换的唯一变换核..........
  • 高斯卷积核C++实现

    2018-07-17 11:10:28
    高斯卷积核模板的C++代码实现,及高斯滤波的介绍和高斯公式分析。
  • "模糊"的算法有很多种,其中有一种叫做"高斯模糊"(Gaussian Blur)。它将正态分布(又名"高斯分布")用于图像处理。 本文介绍"高斯模糊"的算法,你会看到这是一个非常简单易懂的算法。本质上,它是一种数据平滑...
  • 高斯卷积模板(高斯函数)Matlab代码,可实现二维高斯卷积模板的生成功能。M文件,可用记事本打开。
  • 1. 二维高斯核函数参考链接:https://blog.csdn.net/qq_16013649/article/details/78784791g(x, y, sigma) = ... 卷积过程高斯模糊:G(xi, yi, sigma)= img*kernel 3. code# 高斯核函数import numpy as npdef gau...
  • 高斯卷积核具有可分离的性质,因此可以通过以下方法计算二维高斯卷积:构造一个一维高斯卷积核,将原始二维矩阵分别以行主序与列主序,与一维卷积核做卷积计算,得到的结果就是目标二维高斯卷积的结果。本篇按照上述...
  • 卷积 + 高斯核

    万次阅读 多人点赞 2017-11-01 10:30:09
    卷积 计算 1)一维卷积: y(t)=g(k)*x(k)=$g(k)x(t-k) 先把函数x(k)相对于原点反折,然后向右移动距离t,然后两个函数相乘再积分,就得到了在t处的输出。对每个t值重复上述过程,就得到了...
  • 1图像去燥与卷积 ...2高斯卷积核 当卷积核的尺寸不变时,方差越大,高斯分布越扁平,平滑效果明显。 当方差不变时,模板尺寸越大,进行归一化时当前点的值越小,平滑效果越强。 ...
  • "模糊"的算法有很多种,其中有一种叫做"高斯模糊"(Gaussian Blur)。它将正态分布(又名"高斯分布")用于图像处理。 本文介绍"高斯模糊"的算法,你会看到这是一个非常简单易懂的算法。本质上,它是一种数据平滑...
  • 实践高斯模糊卷积核生成公式,C++代码实现,预览标准偏差的影响
  • 而且多出提到高斯核是构建尺度空间的唯一卷积核。 Lowe(2004)也提到: It has been shown by Koenderink (1984) and Lindeberg (1994) that under a variety of reasonable assumptions the only possible scale-...
  • pytorch 自定义高斯核进行卷积操作

    千次阅读 多人点赞 2020-01-08 20:11:40
    高斯滤波的用处很多,也有很多现成的包可以被调用,比如opencv里面的cv2.GaussianBlur,一般情况,我们是没必要去造轮子,除非遇到特殊情况,比如我们在使用pytorch的过程中,需要自定义高斯核进行卷积操作,假设,...
  • 所谓对图像进行卷积运算就是使用卷积核(卷积模板,一般为n*n的奇数方框)在数字图像中进行移动,如图所示,图像中的卷积核大小为3*3的方阵,在图像的滑动过程中卷积核中对应的数值与图像中的数值相乘并对九个数字求和得出...
  • 因此,一维卷积计算成为了实现3D高斯卷积的基础。一维卷积计算的性能直接影响了整个程序的性能。本篇将实现一维卷积功能,同时引出ICC编译器对多层嵌套循环场景的向量化优化倾向的调查结果。 公用函数 这里为了增加...
  • 对BMP图像进行5*5的卷积核运算

    千次阅读 2018-04-28 11:02:04
    未完待续(源代码已完成,因为作业还没结束,因此不便于上传源代码,后续会补上的)....#在做并行计算的时候有这么一个作业从bmp图片文件中读取图像像素数据,使用5×5的卷积核,步长为1,对该图像进行卷积运算,MPI...
  • 高斯滤波卷积核

    千次阅读 2018-12-07 22:27:41
    #二维高斯卷积核 def gaussian_kernel_2d_opencv(kernel_size = 3,sigma = 0): kx = cv2.getGaussianKernel(kernel_size,sigma) ky = cv2.getGaussianKernel(kernel_size,sigma) return np.multiply(kx,np....

空空如也

空空如也

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

高斯卷积核