小编ali*_*i_m的帖子

我正在寻找一种最有效的方法来确定一个大型数组是否包含至少一个非零值.乍一看np.any似乎是这项工作的明显工具,但对大型阵列来说似乎意外地缓慢.

考虑这种极端情况:

first = np.zeros(1E3,dtype=np.bool)
last = np.zeros(1E3,dtype=np.bool)

first[0] = True
last[-1] = True

# test 1
%timeit np.any(first)
>>> 100000 loops, best of 3: 6.36 us per loop

# test 2
%timeit np.any(last)
>>> 100000 loops, best of 3: 6.95 us per loop

至少np.any在这里似乎做了一些模糊的事情 - 如果非零值是数组中的第一个True,那么在返回之前不应该考虑任何其他值,所以我希望测试1比测试2稍快一些.

但是,当我们使阵列更大时会发生什么？

first = np.zeros(1E9,dtype=np.bool)
last = np.zeros(1E9,dtype=np.bool)

first[0] = True
last[-1] = True

# test 3
%timeit np.any(first)
>>> 10 loops, best of 3: 21.6 ms per …

对于mxn矩阵,计算所有列对(nxn)的互信息的最佳(最快)方法是什么？

通过互信,我的意思是:

I(X,Y)= H(X)+ H(Y) - H(X,Y)

其中H(X)是指的香农熵X.

目前我正在使用np.histogram2d并np.histogram计算关节(X,Y)和个体(X或Y)计数.对于给定的矩阵A(例如250000 X 1000浮点矩阵),我正在做一个嵌套for循环,

    n = A.shape[1]
    for ix = arange(n)  
        for jx = arange(ix+1,n):
           matMI[ix,jx]= calc_MI(A[:,ix],A[:,jx])

当然必须有更好/更快的方法来做到这一点？

顺便说一句,我也在数组上寻找列(列式或行式操作)的映射函数,但还没有找到一个很好的通用答案.

这是我的完整实现,遵循Wiki页面中的约定:

import numpy as np

def calc_MI(X,Y,bins):

   c_XY = np.histogram2d(X,Y,bins)[0]
   c_X = np.histogram(X,bins)[0]
   c_Y = np.histogram(Y,bins)[0]

   H_X = shan_entropy(c_X)
   H_Y = shan_entropy(c_Y)
   H_XY = shan_entropy(c_XY)

   MI = H_X + H_Y …

我正在groupby从Pandas 创建一个对象,DataFrame并希望选择> 1大小的所有组.

以下似乎不起作用:

grouped[grouped.size > 1 ]

另外,如何从分组中筛选出某些值DataFrame？例如,如何删除grouped列'name'具有值的所有行'foo'或'bar'？

受控示例:

df = pandas.DataFrame({'A': ['foo','bar','foo','foo'],
                       'B': range(4)})
grouped = df.groupby('A')

groupby删除组大小<= 1的组后,我需要该对象.

我尝试了以下,但没有用:

grouped[grouped.size() > 1]

我期望:

A
foo 0
    2
    3

我不确定索引/切片如何对该grouped对象起作用.

我正在使用一些相当大的,密集的numpy浮点数组,这些数组目前驻留在PyTables CArray的磁盘上.我需要能够执行使用这些阵列效率点的产物,例如C = A.dot(B),其中A是一个巨大的(〜1E4 X 3E5 FLOAT32)存储器映射阵列,以及B和C较小numpy的数组,其驻留在核心存储器.

我现在正在做的是使用数据将数据复制到内存映射的numpy数组中np.memmap,然后np.dot直接调用内存映射数组.这是有效的,但我怀疑标准np.dot(或者它调用的底层BLAS函数)在计算结果所需的I/O操作数量方面可能不是很有效.

我在这篇评论文章中遇到了一个有趣的例子.使用3x嵌套循环计算的天真点积,如下所示:

def naive_dot(A, B, C):
    for ii in xrange(n):
        for jj in xrange(n):
            C[ii,jj] = 0
            for kk in xrange(n):
                C[ii,jj] += A[ii,kk]*B[kk,jj]
    return C

需要O(n ^ 3)个 I/O操作来计算.

但是,通过在适当大小的块中处理数组:

def block_dot(A, B, C, M):
    b = sqrt(M / 3)
    for ii in xrange(0, n, b):
        for jj in xrange(0, n, b):
            C[ii:ii+b,jj:jj+b] = …

在Python 2中有一些工具,但一切似乎都是旧的和过时的.

我发现了PySizer和Heapy但是一切似乎都是面向Python2的,需要付出很多努力来移植.

objgraph很有趣,但仍然不是一个完全工作的分析器

使用哪种工具？

我正在使用scikit-learn和numpy,我想设置全局种子,以便我的工作可以重现.

我应该使用numpy.random.seed或random.seed？

编辑: 从评论中的链接,我知道它们是不同的,并且numpy版本不是线程安全的.我想知道哪一个用于创建IPython笔记本进行数据分析.scikit-learn中的一些算法涉及生成随机数,我想确保笔记本在每次运行时都显示相同的结果.

我希望学生在任务中解决一个二次方程,而不必安装额外的软件,如cvxopt等.是否有可用的python实现只依赖于NumPy/SciPy？

我有一组n个向量存储在3 xn矩阵中z.我找到了外用产品np.einsum.当我使用时间计时:

%timeit v=np.einsum('i...,j...->ij...',z,z)

我得到了结果:

The slowest run took 7.23 times longer than the fastest. This could mean that an
intermediate result is being cached 
100000 loops, best of 3: 2.9 µs per loop

这里发生了什么,可以避免吗？最好的3是2.9us,但最慢可能更典型.

我想在选定的轴上用0填充一个numpy张量.例如,我有r形状的张量,(4,3,2)但我只对填充最后两个轴(即仅填充矩阵)感兴趣.是否可以使用单行python代码？

我很难理解numpy的dstack功能实际上在做什么.文档相当稀疏,只是说:

按顺序深度(沿第三轴)堆叠阵列.

采用一系列数组并沿第三轴堆叠它们以形成单个数组.重建数组除以dsplit.这是将2D阵列(图像)堆叠到单个3D阵列中进行处理的简单方法.

所以要么我真的很愚蠢,这个含义是显而易见的,或者我似乎对"堆叠","按顺序","深度明智"或"沿轴"这两个术语有一些误解.但是,我的印象是我在上下文中理解这些术语,vstack并且hstack很好.

我们来看这个例子:

In [193]: a
Out[193]: 
array([[0, 3],
       [1, 4],
       [2, 5]])
In [194]: b
Out[194]: 
array([[ 6,  9],
       [ 7, 10],
       [ 8, 11]])
In [195]: dstack([a,b])
Out[195]: 
array([[[ 0,  6],
        [ 3,  9]],

       [[ 1,  7],
        [ 4, 10]],

       [[ 2,  8],
        [ 5, 11]]])

首先,a并b没有第三轴,所以我将如何堆叠起来一起" 的第三轴"以开始？第二,假设a并且b是2D图像的表示,为什么我在结果中最终得到三个 2D数组而不是两个"顺序"的2D数组？