编辑我保留了下面我面临的更复杂的问题,但我的问题np.take可以更好地总结如下.假设你有一个img形状数组(planes, rows)和另一个lut形状数组(planes, 256),并且你想用它们来创建一个新out的形状数组(planes, rows),其中out[p,j] = lut[p, img[p, j]].这可以通过如下的花式索引来实现:
In [4]: %timeit lut[np.arange(planes).reshape(-1, 1), img]
1000 loops, best of 3: 471 us per loop
但是,如果使用take和python循环而不是花哨的索引,那么planes事情可以大大加快:
In [6]: %timeit for _ in (lut[j].take(img[j]) for j in xrange(planes)) : pass
10000 loops, best of 3: 59 us per loop
可以lut并且img在某种程度上重新排列,以便在没有python循环的情况下进行整个操作,但是使用numpy.take(或替代方法)而不是传统的花式索引来保持速度优势？
原始问题
我有一组想要在图像上使用的查找表(LUT).保持LUT的阵列具有形状(planes, 256, n),并且图像具有形状(planes, rows, …
m1 = [0,1,1,3]
m2 = [0,0,1,1]
data = [10,20,30,40]
我想做这样的事情:
mask = (m1 == 1) & (m2 == 1)
data[mask] #should return 30
请注意,此示例会导致错误
我看到Python 2和3之间的行为有一种奇怪的差异.
在Python 3中,似乎工作正常:
Python 3.5.0rc2 (v3.5.0rc2:cc15d736d860, Aug 25 2015, 04:45:41) [MSC v.1900 32 b
it (Intel)] on win32
>>> from collections import Sequence
>>> isinstance(bytearray(b"56"), Sequence)
True
但不是在Python 2中:
Python 2.7.10 (default, May 23 2015, 09:44:00) [MSC v.1500 64 bit (AMD64)] on wi
n32
>>> from collections import Sequence
>>> isinstance(bytearray("56"), Sequence)
False
在Python 2.x和3.x的次要版本中,结果似乎是一致的.这是一个已知的错误？它是一个bug吗？这种差异背后有什么逻辑吗？
我实际上更担心C API函数PySequence_Check正确识别类型的对象,PyByteArray_Type因为它暴露了序列协议,通过查看它看起来应该的源代码,但是对这整个事物的任何洞察都是非常受欢迎的.
我真的不知道从哪里开始这个问题,因为我没有太多经验,但需要使用计算机解决项目的这一部分.
我有一个二阶ODE,它是:
m = 1220
k = 35600
g = 17.5
a = 450000
和b在1000和10000之间,增量为500.
x(0)= 0
x'(0)= 5
m*x''(t) + b*x'(t) + k*x(t)+a*(x(t))^3 = -m*g
我需要找到最小的b,这样解决方案永远不会是积极的.我知道图形应该是什么样的,但我只是不知道如何使用odeint来获得微分方程的解.这是我到目前为止的代码:
from numpy import *
from matplotlib.pylab import *
from scipy.integrate import odeint
m = 1220.0
k = 35600.0
g = 17.5
a = 450000.0
x0= [0.0,5.0]
b = 1000
tmax = 10
dt = 0.01
def fun(x, t):
return (b*x[1]-k*x[0]-a*(x[0]**3)-m*g)*(1.0/m)
t_rk = arange(0,tmax,dt)
sol = odeint(fun, x0, t_rk)
plot(t_rk,sol)
show()
哪个并没有真正产生任何东西.
有什么想法吗？谢谢
我在C中有一个动态分配缓冲区的函数,它被传递给另一个函数来存储它的返回值.像下面的虚拟示例:
void other_function(float in, float *out, int out_len) {
/* Fills 'out' with 'out_len' values calculated from 'in' */
}
void function(float *data, int data_len, float *out) {
float *buf;
int buf_len = 2 * data_len, i;
buf = malloc(sizeof(float) * buf_len);
for (i = 0; i < data_len; i++, data++, out++) {
other_function(*data, buf, buf_len);
/* Do some other stuff with the contents of buf and write to *out */
}
free buf;
}
function是通过在一个多维阵列(它是一个NumPy的gufunc内核,要准确)的迭代器调用,所以它被与相同的值称为数百万次data_len.一遍又一遍地创建和销毁缓冲区似乎很浪费.我通常会将缓冲区的分配移动到调用的函数function …
我喜欢能够测量我编码的python函数的性能,所以我经常做类似的事情......
import time
def some_function(arg1, arg2, ..., argN, verbose = True) :
t = time.clock() # works best in Windows
# t = time.time() # apparently works better in Linux
# Function code goes here
t = time.clock() - t
if verbose :
print "some_function executed in",t,"sec."
return return_val
是的,我知道你应该用timeit测量性能,但这对我的需求来说很好,并且允许我打开和关闭这些信息以便非常顺利地进行调试.
那段代码当然是在我了解函数装饰器之前...不是我现在对它们了解很多,但我想我可以使用**kwds字典编写一个装饰器来执行以下操作:
some_function(arg1, arg2, ..., argN) # Does not time function
some_function(arg1, arg2, ..., argN, verbose = True) # Times function
不过,我想复制我的函数的先前工作,以便工作更像是:
some_function(arg1, arg2, ..., argN) # Does not time function …我有一个图像,存储在一个uint8形状为n的numpy数组中(planes, rows, cols).我需要将它与存储在掩模(也是uint8s)形状中的值进行比较(mask_rows, mask_cols).虽然图像可能非常大,但是掩模通常很小,通常(256, 256)是平铺的image.为了简化代码,让我们假装rows = 100 * mask_rows和cols = 100 * mask_cols.
我目前处理这个阈值的方式是这样的:
out = image >= np.tile(mask, (image.shape[0], 100, 100))
我可以用这种方式处理的最大阵列,然后用MemoryError比a大一点的方式拍打脸部(3, 11100, 11100).我想的方式,这样做的方式我在内存中共存最多三个巨大的数组:image平铺mask,我的回归out.但是,平铺的掩码是相同的小数组,复制超过10,000次.因此,如果我可以节省内存,我只会使用2/3的内存,并且应该能够处理大于3/2的图像(3, 13600, 13600).顺便说一句,这与我得到的阈值一致
np.greater_equal(image, (image.shape[0], 100, 100), out=image)
我(尝试失败)尝试利用mask处理更大数组的周期性,已经mask使用周期性线性数组进行索引:
mask = mask[None, ...]
rows = np.tile(np.arange(mask.shape[1], (100,))).reshape(1, -1, 1)
cols = np.tile(np.arange(mask.shape[2], (100,))).reshape(1, 1, …我有一个存储65536个uint8值的查找表(LUT):
lut = np.random.randint(256, size=(65536,)).astype('uint8')
我想使用此LUT转换uint16s 数组中的值:
arr = np.random.randint(65536, size=(1000, 1000)).astype('uint16')
我想要进行转换,因为最后一个数组可能会变得非常大.当我尝试它时,会发生以下情况:
>>> np.take(lut, arr, out=arr)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "C:\Python27\lib\site-packages\numpy\core\fromnumeric.py", line 103, in take
return take(indices, axis, out, mode)
TypeError: array cannot be safely cast to required type
我不明白发生了什么.我知道,没有一个out参数,返回的是相同的D型的lut,所以uint8.但为什么不能uint8被投入uint16？如果你问numpy:
>>> np.can_cast('uint8', 'uint16')
True
显然以下工作:
>>> lut = lut.astype('uint16')
>>> np.take(lut, arr, out=arr)
array([[173, 251, 218, ..., …我是Python的新手,我遇到了一个问题,我无法用找到的答案解决...希望有人可以提供帮助:我需要获取一个从csv文件导入的数据集的所有局部最大值的列表.值的范围从0到0.5左右.
我只需要获取一个数据行("Werte",数组或"N",列表)的局部最大值列表来对它们进行统计.
这就是我所拥有的:
import numpy as np
from numpy import *
N = []
file = open('C:/Auswertung/PEE/PEE_L_1_O_130702-1.1.csv', 'r')
Probe = file.readline() # lese Inhalt zeilenweise in Listen
Header = file.readline()
data = file.readlines()
for row in data:
columns = row.split(";") # Trenne Zeilen bei ';'
N.append(float(columns[1]))
Werte = np.array([N])
# one try here: only gives me a set of 1s...
c = (diff(sign(diff(Werte))) < 0).nonzero()[0] + 1 # local max
print(c)
有没有人可以帮我找到正确的方法呢？非常感谢!
以下代码甚至不会在我的系统上完成:
import numpy as np
from scipy import sparse
p = 100
n = 50
X = np.random.randn(p,n)
L = sparse.eye(p,p, format='csc')
X.T.dot(L).dot(X)
有没有解释为什么这个矩阵乘法挂起？