我正在制作一些带有熊猫的交叉表:
a = np.array(['foo', 'foo', 'foo', 'bar', 'bar', 'foo', 'foo'], dtype=object)
b = np.array(['one', 'one', 'two', 'one', 'two', 'two', 'two'], dtype=object)
c = np.array(['dull', 'dull', 'dull', 'dull', 'dull', 'shiny', 'shiny'], dtype=object)
pd.crosstab(a, [b, c], rownames=['a'], colnames=['b', 'c'])
b one two
c dull dull shiny
a
bar 1 1 0
foo 2 1 2
但我真正想要的是以下内容:
b one two
c dull shiny dull shiny
a
bar 1 0 1 0
foo 2 0 1 2
我通过添加新列和设置级别作为新的MultiIndex找到了解决方法,但似乎很难......
有没有办法将MultiIndex传递给交叉表函数来预定义输出列？
我最近询问了如何为科学应用程序优化Python循环,并在NumPy中获得了一种优秀,智能的重新编码方式,这使我的执行时间减少了大约100倍!
但是,值的计算B实际上嵌套在其他几个循环中,因为它是在常规的位置网格上进行计算的.有没有类似的智能NumPy重写来削减这个程序的时间？
我怀疑这部分的性能提升不太明显,并且缺点可能是不可能向用户报告计算的进度,结果无法写入输出文件,直到计算的结束,并且可能在一个巨大的步骤中这样做会产生内存影响吗？有可能绕过这些吗？
import numpy as np
import time
def reshape_vector(v):
b = np.empty((3,1))
for i in range(3):
b[i][0] = v[i]
return b
def unit_vectors(r):
return r / np.sqrt((r*r).sum(0))
def calculate_dipole(mu, r_i, mom_i):
relative = mu - r_i
r_unit = unit_vectors(relative)
A = 1e-7
num = A*(3*np.sum(mom_i*r_unit, 0)*r_unit - mom_i)
den = np.sqrt(np.sum(relative*relative, 0))**3
B = np.sum(num/den, 1)
return B
N = 20000 # number of dipoles
r_i = np.random.random((3,N)) # positions …以下代码
import numpy as np
import itertools
a_p1 = np.arange(0, 4, 1)
a_p2 = np.arange(20, 25, 1)
params = itertools.product(a_p1, a_p2)
for (p1, p2) in params:
print(p1, p2)
输出
(0, 20) (0, 21) (0, 22) (0, 23) (0, 24) (1, 20) (1, 21) (1, 22) (1, 23) (1, 24) (2, 20) (2, 21) (2, 22) (2, 23) (2, 24) (3, 20) (3, 21) (3, 22) (3, 23) (3, 24)
2嵌套for循环也可以输出相同的结果
for i, p1 in enumerate(a_p1):
for j, p2 in enumerate(a_p2): …问题:
输入是(i,j) - 矩阵M.期望的输出是(i ^ n,j ^ n)矩阵K,其中n是所采用的乘积的数量.获得所需输出的详细方法如下
我这样做的直接方法是生成范围内所有n个排列数的标签列表(len(np.shape(m)[0]))和范围(len(np.shape(m)[ 1]))分别用于行和列.之后,您可以将它们乘以上面的最后一个项目符号点.然而,这对于大输入矩阵是不实用的 - 所以我正在寻找优化上述方法的方法.先感谢您
例:
输入
np.array([[1,2,3],[4,5,6]])
输出n = 3
[[1. 2. 3. 2. 4. 6. 3. 6. 9. 2. 4. 6. 4. 8. 12. 6. 12. 18. 3. 6. 9. 6. 12. 18. 9. 18. 27.]
[4. 5. 6. 8. 10. 12. 12. 15. 18. 8. 10. 12. 16. 20. 24. 24. 30. 36. 12. 15. 18. …
我使用itertools.combinations()如下:
import itertools
import numpy as np
L = [1,2,3,4,5]
N = 3
output = np.array([a for a in itertools.combinations(L,N)]).T
这产生了我需要的输出:
array([[1, 1, 1, 1, 1, 1, 2, 2, 2, 3],
[2, 2, 2, 3, 3, 4, 3, 3, 4, 4],
[3, 4, 5, 4, 5, 5, 4, 5, 5, 5]])
我在多处理环境中反复使用这个表达式,我需要它尽可能快.
从这篇文章中我了解到,itertools基于代码的代码并不是最快的解决方案,并且使用numpy可能是一种改进,但是我numpy对于理解和调整在那里编写的迭代代码或者提出我自己的优化的优化技巧还不够好..
任何帮助将不胜感激.
编辑:
L 来自熊猫数据帧,所以它也可以看作是一个numpy数组:
L = df.L.values
我正在尝试编写一个将2d-ndarray映射到2d-ndarray的函数.输入数组的行可以独立处理,输入行和输出行之间应该有一对一的对应关系.对于输入的每一行,应计算该行的给定顺序的多项式展开(有关示例,请参见docstring).目前的实施工作; 但是它需要在"powerMatrix"中对行和行的重复进行显式循环.通过一次调用numpy.power可以获得相同的结果吗？顺便说一句:结果行中条目的顺序对我来说无关紧要.
import numpy
def polynomialFeatures(x, order):
""" Generate polynomial features of given order for data x.
For each row of ndarray x, the polynomial expansions are computed, i.e
for row [x1, x2] and order 2, the following row of the result matrix is
computed: [1, x1, x1**2, x2, x1*x2, x1**2*x2, x2**2, x1*x2**2, x1**2*x2**2]
Parameters
----------
x : array-like
2-D array; for each of its rows, the polynomial features are created
order : int
The order of the polynomial features …我希望生成相对大量阵列的笛卡尔积,以跨越高维网格.由于高维度,不可能将笛卡尔积计算的结果存储在存储器中; 而是它将被写入硬盘.由于这种约束,我需要在生成中间结果时访问它们.到目前为止我一直在做的是:
for x in xrange(0, 10):
for y in xrange(0, 10):
for z in xrange(0, 10):
writeToHdd(x,y,z)
除了非常讨厌之外,它不可扩展(即它需要我编写与维度一样多的循环).我试图使用这里提出的解决方案,但这是一个递归解决方案,因此很难在生成时动态获取结果.除了每个维度有一个硬编码循环之外,还有什么"整洁"的方法吗？
想象一下，您正尝试n=10在一定数量的区域（例如 ）上分配一些固定资源（例如t=5）。我正在尝试有效地找出如何获得总和等于n或低于的所有组合。
例如10,0,0,0,0是好的，等等0,0,5,5,0，而3,3,3,3,3,3显然是错误的。
我到目前为止：
import itertools
t = 5
n = 10
r = [range(n+1)] * t
for x in itertools.product(*r):
if sum(x) <= n:
print x
然而，这种蛮力方法的速度非常慢；一定会有更好的办法？
计时（1000 次迭代）：
Default (itertools.product) --- time: 40.90 s
falsetru recursion --- time: 3.63 s
Aaron Williams Algorithm (impl, Tony) --- time: 0.37 s
例如[0,0,0],给定两个数组,[1,1,1]已经清楚(见此处)如何生成所有组合,即[[0,0,0],[0,0,1],[0,1,0],[0,1,1],[1,0,0],[1,0,1],[1,1,0],[1,1,1]].itertools(combinations或product)并且numpy.meshgrid是我所知道的最常见的方式.
但是,我找不到关于如何随机生成这种组合的任何讨论,而不重复.
一个简单的解决方案可能是生成所有组合,然后随机选择其中一些.例如:
# Three random combinations of [0,0,0] and [1,1,1]
comb = np.array(np.meshgrid([0,1],[0,1],[0,1])).T.reshape(-1,3)
result = comb[np.random.choice(len(comb),3,replace=False),:]
然而,当组合的数量太大时,这是不可行的.
有没有办法生成随机组合而无需在Python中替换(可能使用Numpy)而不生成所有组合？
编辑:您可以在接受的答案中注意到,我们也免费获得了一种生成随机二进制向量而无需重复的技术,这只是一条线(在红利部分中描述).
我有两个不同长度的数组。一个包含匀称的多边形，另一个包含匀称的点。我想为两个数组中的每个可能的元素组合运行 a_polygon.contains(a_point) 匀称的函数。
我正在看这篇文章，因为构建一个包含行中所有可能组合的两列矩阵可能是一个理想的中间步骤。但是当输入数据很大时，'cartersian(arrays)' 函数中的循环可能会影响性能。
我尝试广播其中一个数组，然后应用 shapely 函数：
Polygons_array[:,newaxis].contains(Points_array)
但这当然是行不通的。我知道最近发布的 geopandas 库，但它不是我的 Canopy 安装的一个选项。