- html - 出于某种原因,IE8 对我的 Sass 文件中继承的 html5 CSS 不友好?
- JMeter 在响应断言中使用 span 标签的问题
- html - 在 :hover and :active? 上具有不同效果的 CSS 动画
- html - 相对于居中的 html 内容固定的 CSS 重复背景?
我有一个非常大的数组,其中只有几个感兴趣的小区域。我需要计算此数组的梯度,但出于性能原因,我需要将此计算限制在这些感兴趣的区域。
我不能做这样的事情:
phi_grad0[mask] = np.gradient(phi[mask], axis=0)
由于奇特的索引工作方式,phi[mask]
只是变成了屏蔽像素的一维数组,丢失了空间信息并使梯度计算毫无值(value)。
np.gradient
确实可以处理 np.ma.masked_array
,但性能要差一个数量级:
import numpy as np
from timeit_context import timeit_context
phi = np.random.randint(low=-100, high=100, size=[100, 100])
phi_mask = np.random.randint(low=0, high=2, size=phi.shape, dtype=np.bool)
with timeit_context('full array'):
for i2 in range(1000):
phi_masked_grad1 = np.gradient(phi)
with timeit_context('masked_array'):
phi_masked = np.ma.masked_array(phi, ~phi_mask)
for i1 in range(1000):
phi_masked_grad2 = np.gradient(phi_masked)
这会产生以下输出:
[full array] finished in 143 ms
[masked_array] finished in 1961 ms
我认为这是因为在 masked_array
上运行的操作未矢量化,但我不确定。
有没有办法限制np.gradient
以获得更好的性能?
这个 timeit_context
是一个像这样工作的方便的计时器,如果有人感兴趣的话:
from contextlib import contextmanager
import time
@contextmanager
def timeit_context(name):
"""
Use it to time a specific code snippet
Usage: 'with timeit_context('Testcase1'):'
:param name: Name of the context
"""
start_time = time.time()
yield
elapsed_time = time.time() - start_time
print('[{}] finished in {} ms'.format(name, int(elapsed_time * 1000)))
最佳答案
不完全是一个答案,但这是我设法针对我的情况拼凑起来的,效果很好:
我得到条件为真的像素的一维索引(例如,在这种情况下,条件为 < 5
):
def get_indices_1d(image, band_thickness):
return np.where(image.reshape(-1) < 5)[0]
这为我提供了一个包含这些索引的一维数组。
然后我以不同的方式手动计算这些位置的梯度:
def gradient_at_points1(image, indices_1d):
width = image.shape[1]
size = image.size
# Using this instead of ravel() is more likely to produce a view instead of a copy
raveled_image = image.reshape(-1)
res_x = 0.5 * (raveled_image[(indices_1d + 1) % size] - raveled_image[(indices_1d - 1) % size])
res_y = 0.5 * (raveled_image[(indices_1d + width) % size] - raveled_image[(indices_1d - width) % size])
return [res_y, res_x]
def gradient_at_points2(image, indices_1d):
indices_2d = np.unravel_index(indices_1d, dims=image.shape)
# Even without doing the actual deltas this is already slower, and we'll have to check boundary conditions, etc
res_x = 0.5 * (image[indices_2d] - image[indices_2d])
res_y = 0.5 * (image[indices_2d] - image[indices_2d])
return [res_y, res_x]
def gradient_at_points3(image, indices_1d):
width = image.shape[1]
raveled_image = image.reshape(-1)
res_x = 0.5 * (raveled_image.take(indices_1d + 1, mode='wrap') - raveled_image.take(indices_1d - 1, mode='wrap'))
res_y = 0.5 * (raveled_image.take(indices_1d + width, mode='wrap') - raveled_image.take(indices_1d - width, mode='wrap'))
return [res_y, res_x]
def gradient_at_points4(image, indices_1d):
width = image.shape[1]
raveled_image = image.ravel()
res_x = 0.5 * (raveled_image.take(indices_1d + 1, mode='wrap') - raveled_image.take(indices_1d - 1, mode='wrap'))
res_y = 0.5 * (raveled_image.take(indices_1d + width, mode='wrap') - raveled_image.take(indices_1d - width, mode='wrap'))
return [res_y, res_x]
我的测试数组是这样的:
a = np.random.randint(-10, 10, size=[512, 512])
# Force edges to not pass the condition
a[:, 0] = 99
a[:, -1] = 99
a[0, :] = 99
a[-1, :] = 99
indices = get_indices_1d(a, 5)
mask = a < 5
然后我可以运行这些测试:
with timeit_context('full gradient'):
for i in range(100):
grad1 = np.gradient(a)
with timeit_context('With masked_array'):
for im in range(100):
ma = np.ma.masked_array(a, mask)
grad6 = np.gradient(ma)
with timeit_context('gradient at points 1'):
for i1 in range(100):
grad2 = gradient_at_points1(image=a, indices_1d=indices)
with timeit_context('gradient at points 2'):
for i2 in range(100):
grad3 = gradient_at_points2(image=a, indices_1d=indices)
with timeit_context('gradient at points 3'):
for i3 in range(100):
grad4 = gradient_at_points3(image=a, indices_1d=indices)
with timeit_context('gradient at points 4'):
for i4 in range(100):
grad5 = gradient_at_points4(image=a, indices_1d=indices)
结果如下:
[full gradient] finished in 576 ms
[With masked_array] finished in 3455 ms
[gradient at points 1] finished in 421 ms
[gradient at points 2] finished in 451 ms
[gradient at points 3] finished in 112 ms
[gradient at points 4] finished in 102 ms
如您所见,方法 4 是迄今为止最好的方法(不过不要太在意它消耗多少内存)。
这可能只是因为我的二维数组相对较小 (512x512)。也许对于更大的阵列,这不是真的。
另一个警告是 ndarray.take(indices, mode='wrap')
将在图像边缘周围做一些奇怪的事情(一行将“循环”到下一行,等等)以保持良好的性能,因此如果边缘对您的应用程序很重要,您可能希望在边缘周围填充 1 个像素的输入数组.
还是 super 有趣多慢啊masked_array
是。拉动构造函数ma = np.ma.masked_array(a, mask)
循环外不影响自 masked_array
以来的时间本身只是保留对数组及其掩码的引用
关于python - 仅在 mask 区域计算梯度,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/45169105/
我正在尝试调整 tf DeepDream 教程代码以使用另一个模型。现在当我调用 tf.gradients() 时: t_grad = tf.gradients(t_score, t_input)[0
考虑到 tensorflow 中 mnist 上的一个简单的小批量梯度下降问题(就像在这个 tutorial 中),我如何单独检索批次中每个示例的梯度。 tf.gradients()似乎返回批次中所有
当我在 numpy 中计算屏蔽数组的梯度时 import numpy as np import numpy.ma as ma x = np.array([100, 2, 3, 5, 5, 5, 10,
除了数值计算之外,是否有一种快速方法来获取协方差矩阵(我的网络激活)的导数? 我试图将其用作深度神经网络中成本函数中的惩罚项,但为了通过我的层反向传播误差,我需要获得导数。 在Matlab中,如果“a
我有一个计算 3D 空间标量场值的函数,所以我为它提供 x、y 和 z 坐标(由 numpy.meshgrid 获得)的 3D 张量,并在各处使用元素运算。这按预期工作。 现在我需要计算标量场的梯度。
我正在使用内核密度估计 (KDE) ( http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gaussian_kde.htm
我对 tensorflow gradient documentation 中的示例感到困惑用于计算梯度。 a = tf.constant(0.) b = 2 * a g = tf.gradients(
我有一个 softmax 层(只有激活本身,没有将输入乘以权重的线性部分),我想对其进行向后传递。 我找到了很多关于 SO 的教程/答案来处理它,但它们似乎都使用 X 作为 (1, n_inputs)
仅供引用,我正在尝试使用 Tensorflow 实现梯度下降算法。 我有一个矩阵X [ x1 x2 x3 x4 ] [ x5 x6 x7 x8 ] 我乘以一些特征向量 Y 得到 Z [ y
我目前有一个由几百万个不均匀分布的粒子组成的体积,每个粒子都有一个属性(对于那些好奇的人来说是潜在的),我想为其计算局部力(加速度)。 np.gradient 仅适用于均匀间隔的数据,我在这里查看:S
我正在寻找有关如何实现 Gradient (steepest) Descent 的建议在 C 中。我正在寻找 f(x)=||Ax-y||^2 的最小值,其中给出了 A(n,n) 和 y(n)。 这在
我正在查看 SVM 损失和导数的代码,我确实理解了损失,但我无法理解如何以矢量化方式计算梯度 def svm_loss_vectorized(W, X, y, reg): loss = 0.0 dW
我正在寻找一种有效的方法来计算 Julia 中多维数组的导数。准确地说,我想要一个等效的 numpy.gradient在 Julia 。但是,Julia 函数 diff : 仅适用于二维数组 沿微分维
我在cathesian 2D 系统中有两个点,它们都给了我向量的起点和终点。现在我需要新向量和 x 轴之间的角度。 我知道梯度 = (y2-y1)/(x2-x1) 并且我知道角度 = arctan(g
我有一个 2D 数组正弦模式,想要绘制该函数的 x 和 y 梯度。我有一个二维数组 image_data : def get_image(params): # do some maths on
假设我有一个针对 MNIST 数据的简单 TensorFlow 模型,如下所示 import tensorflow as tf from tensorflow.examples.tutorials.m
我想查看我的 Tensorflow LSTM 随时间变化的梯度,例如,绘制从 t=N 到 t=0 的梯度范数。问题是,如何从 Tensorflow 中获取每个时间步长的梯度? 最佳答案 在图中定义:
我有一个简单的神经网络,我试图通过使用如下回调使用张量板绘制梯度: class GradientCallback(tf.keras.callbacks.Callback): console =
在CIFAR-10教程中,我注意到变量被放置在CPU内存中,但它在cifar10-train.py中有说明。它是使用单个 GPU 进行训练的。 我很困惑..图层/激活是否存储在 GPU 中?或者,梯度
我有一个 tensorflow 模型,其中层的输出是二维张量,例如 t = [[1,2], [3,4]] . 下一层需要一个由该张量的每一行组合组成的输入。也就是说,我需要把它变成t_new = [[
我是一名优秀的程序员,十分优秀!