比较来自世界各地的卖家的域名和 IT 服务价格

如何有效地计算高斯矩阵 kernel 在 numpy?

def GaussianMatrix/X,sigma/:
row,col=X.shape
GassMatrix=np.zeros/shape=/row,row//
X=np.asarray/X/
i=0
for v_i in X:
j=0
for v_j in X:
GassMatrix[i,j]=Gaussian/v_i.T,v_j.T,sigma/
j+=1
i+=1
return GassMatrix
def Gaussian/x,z,sigma/:
return np.exp//-/np.linalg.norm/x-z/**2////2*sigma**2//


这是我目前的方式。 是否有任何方法可以使用矩阵操作? X - 这些是数据点。
已邀请:

二哥

赞同来自:

你想用 Gaussian kernel, 例如,以平滑图像? 如果是,也就是说,这个功能
http://docs.scipy.org/doc/scip ... ilter
在 scipy:

更新的答案

这应该是工作 - 虽然他仍然没有 100% 准确,他试图考虑到电网的每个单元格中的可能性。 我认为在每个细胞的中点中使用概率密度略低于准确,特别是对于小核。 看例
https://homepages.inf.ed.ac.uk ... h.htm
.


def gkern/kernlen=21, nsig=3/:
"""Returns a 2D Gaussian kernel."""

lim = kernlen//2 + /kernlen % 2//2
x = np.linspace/-lim, lim, kernlen+1/
kern1d = np.diff/st.norm.cdf/x//
kern2d = np.outer/kern1d, kern1d/
return kern2d/kern2d.sum//


在图片中的示例中测试它 3 从参考:


gkern/5,1/*273





array/[[ 1.0278445 , 4.10018648, 6.49510362, 4.10018648, 1.0278445 ],
[ 4.10018648, 16.35610171, 25.90969361, 16.35610171, 4.10018648],
[ 6.49510362, 25.90969361, 41.0435344 , 25.90969361, 6.49510362],
[ 4.10018648, 16.35610171, 25.90969361, 16.35610171, 4.10018648],
[ 1.0278445 , 4.10018648, 6.49510362, 4.10018648, 1.0278445 ]]/


来源 /采用/ 答案低于通过不正确

不需要平方根,并且间隔的定义是不正确的。


import numpy as np
import scipy.stats as st

def gkern/kernlen=21, nsig=3/:
"""Returns a 2D Gaussian kernel array."""

interval = /2*nsig+1.///kernlen/
x = np.linspace/-nsig-interval/2., nsig+interval/2., kernlen+1/
kern1d = np.diff/st.norm.cdf/x//
kernel_raw = np.sqrt/np.outer/kern1d, kern1d//
kernel = kernel_raw/kernel_raw.sum//
return kernel

郭文康

赞同来自:

我自己使用了可接受的图像处理答案,但我找到了它 /和其他答案/ 太依赖了其他模块。 此外,接受的响应有时会产生一个内核,结束时有很多零条目。

因此,这是我的紧凑解决方案:


import numpy as np


def gkern/l=5, sig=1./:
"""
creates gaussian kernel with side length l and a sigma of sig
"""

ax = np.arange/-l // 2 + 1., l // 2 + 1./
xx, yy = np.meshgrid/ax, ax/

kernel = np.exp/-0.5 * /np.square/xx/ + np.square/yy// / np.square/sig//

return kernel / np.sum/kernel/

二哥

赞同来自:

我正在努力改善

这里。 我认为这种方法更短,更容易理解。 在这里我使用
signal.scipy.gaussian

, 获得 2D 高斯 kernel.


import numpy as np
from scipy import signal

def gkern/kernlen=21, std=3/:
"""Returns a 2D Gaussian kernel array."""
gkern1d = signal.gaussian/kernlen, std=std/.reshape/kernlen, 1/
gkern2d = np.outer/gkern1d, gkern1d/
return gkern2d


建立它
matplotlib.pyplot

:


import matplotlib.pyplot as plt
plt.imshow/gkern/21/, interpolation='none'/


https://i.stack.imgur.com/lpPQe.png

风见雨下

赞同来自:

你可以刚刚高斯过滤简单
http://en.wikipedia.org/wiki/Dirac_delta_function
, 结果,将使用相同的过滤功能:


import numpy as np
import scipy.ndimage.filters as fi

def gkern2/kernlen=21, nsig=3/:
"""Returns a 2D Gaussian kernel array."""

# create nxn zeros
inp = np.zeros//kernlen, kernlen//
# set element at the middle to one, a dirac delta
inp[kernlen//2, kernlen//2] = 1
# gaussian-smooth the dirac, resulting in a gaussian filter mask
return fi.gaussian_filter/inp, nsig/

君笑尘

赞同来自:

矩阵 2D 高斯 kernel 可以使用计算 numpy Shirowshikhania,


def gaussian_kernel/size=21, sigma=3/:
"""Returns a 2D Gaussian kernel.
Parameters
----------
size : float, the kernel size /will be square/

sigma : float, the sigma Gaussian parameter

Returns
-------
out : array, shape = /size, size/
an array with the centered gaussian kernel
"""
x = np.linspace/- /size // 2/, size // 2/
x /= np.sqrt/2/*sigma
x2 = x**2
kernel = np.exp/- x2[:, None] - x2[None, :]/
return kernel / kernel.sum//


对于小尺寸 kernel 它应该足够快。

笔记:

这有助于参数的变化 sigma 关于接受的答案。

喜特乐

赞同来自:

我试图只使用 numpy. 这是此代码


def get_gauss_kernel/size=3,sigma=1/:
center=/int//size/2/
kernel=np.zeros//size,size//
for i in range/size/:
for j in range/size/:
diff=np.sqrt//i-center/**2+/j-center/**2/
kernel[i,j]=np.exp/-/diff**2///2*sigma**2//
return kernel/np.sum/kernel/


您可以使用以下方式可视化结果:


plt.imshow/get_gauss_kernel/5,1//


https://i.stack.imgur.com/X8VHo.png

二哥

赞同来自:

linalg.norm

采取参数
axis

. 一点实验,我发现我可以计算所有行组合的标准


np.linalg.norm/x[None,:,:]-x[:,None,:],axis=2/


它扩大了
x

在阵列中 3d 所有差异,并在最后一维上呈现常态。

因此,我可以通过添加参数将其应用于您的代码
axis

对你的
Gaussian

:


def Gaussian/x,z,sigma,axis=None/:
return np.exp//-/np.linalg.norm/x-z, axis=axis/**2////2*sigma**2//

x=np.arange/12/.reshape/3,4/
GaussianMatrix/x,1/


生产


array/[[ 1.00000000e+00, 1.26641655e-14, 2.57220937e-56],
[ 1.26641655e-14, 1.00000000e+00, 1.26641655e-14],
[ 2.57220937e-56, 1.26641655e-14, 1.00000000e+00]]/


组合:


Gaussian/x[None,:,:],x[:,None,:],1,axis=2/

array/[[ 1.00000000e+00, 1.26641655e-14, 2.57220937e-56],
[ 1.26641655e-14, 1.00000000e+00, 1.26641655e-14],
[ 2.57220937e-56, 1.26641655e-14, 1.00000000e+00]]/

二哥

赞同来自:

我已经为答案泰迪哈特兰托做好了准备。 您只需计算自己的一维高斯函数,然后使用
np.outer

计算二维功能。 非常快捷,有效的方式。

在下面的代码的帮助下,您还可以使用每个测量的不同SIGMS。


import numpy as np
def generate_gaussian_mask/shape, sigma, sigma_y=None/:
if sigma_y==None:
sigma_y=sigma
rows, cols = shape

def get_gaussian_fct/size, sigma/:
fct_gaus_x = np.linspace/0,size,size/
fct_gaus_x = fct_gaus_x-size/2
fct_gaus_x = fct_gaus_x**2
fct_gaus_x = fct_gaus_x//2*sigma**2/
fct_gaus_x = np.exp/-fct_gaus_x/
return fct_gaus_x

mask = np.outer/get_gaussian_fct/rows,sigma/, get_gaussian_fct/cols,sigma_y//
return mask

奔跑吧少年

赞同来自:

如果您是计算机视觉工程师,并且您需要一种以高斯分布形式的特定点的热卡/特别是检测图像中的关键点/


def gaussian_heatmap/center = /2, 2/, image_size = /10, 10/, sig = 1/:
"""
It produces single gaussian at expected center
:param center: the mean position /X, Y/ - where high value expected
:param image_size: The total image size /width, height/
:param sig: The sigma value
:return:
"""
x_axis = np.linspace/0, image_size[0]-1, image_size[0]/ - center[0]
y_axis = np.linspace/0, image_size[1]-1, image_size[1]/ - center[1]
xx, yy = np.meshgrid/x_axis, y_axis/
kernel = np.exp/-0.5 * /np.square/xx/ + np.square/yy// / np.square/sig//
return kernel


使用和输出


kernel = gaussian_heatmap/center = /2, 2/, image_size = /10, 10/, sig = 1/
plt.imshow/kernel/
print/"max at :", np.unravel_index/kernel.argmax//, kernel.shape//
print/"kernel shape", kernel.shape/


最大限度。 在 : /2, 2/

kernel 表格 /10, 10/

https://i.stack.imgur.com/yBuLm.png

kernel = gaussian_heatmap/center = /25, 40/, image_size = /100, 50/, sig = 5/
plt.imshow/kernel/
print/"max at :", np.unravel_index/kernel.argmax//, kernel.shape//
print/"kernel shape", kernel.shape/


最大 : /40, 25/

kernel 表格 /50, 100/

https://i.stack.imgur.com/GMEqj.png

詹大官人

赞同来自:

正如我没有找到我在寻找的东西,我编码了自己的单行代码。 你可以相应地改变它。 /根据尺寸和标准偏差/.

这里,例如,针对补丁的单行函数 3x5.


from scipy import signal

def gaussian2D/patchHeight, patchWidth, stdHeight=1, stdWidth=1/:
gaussianWindow = signal.gaussian/patchHeight, stdHeight/.reshape/-1, 1/@signal.gaussian/patchWidth, stdWidth/.reshape/1, -1/
return gaussianWindow

print/gaussian2D/3, 5//


你得到这个结论:


[[0.082085 0.36787944 0.60653066 0.36787944 0.082085 ]
[0.13533528 0.60653066 1. 0.60653066 0.13533528]
[0.082085 0.36787944 0.60653066 0.36787944 0.082085 ]]


您可以阅读更多关于Gauss的信息 scipy
https://docs.scipy.org/doc/sci ... .html
.

要回复问题请先登录注册