小编Cup*_*tor的帖子

正如在此示例代码中所见，由于 0 在频谱中的某个位置，因此很难追踪哪些点是负的，哪些是正的。虽然我的真实情节更连续，但我想知道是否有办法在这些情节图中分离负值和正值；例如，我如何为正值和负值使用两种不同的颜色光谱。

import numpy as np
from matplotlib import pyplot as plt
a=np.random.randn(2500).reshape((50,50))
plt.imshow(a,interpolation='none')
plt.colorbar()
plt.show()

编辑 在@MultiVAC 的帮助下，我在寻找解决方案时遇到了这个问题。

import numpy as np
from matplotlib import pyplot as plt
from matplotlib.colors import BoundaryNorm
a=np.random.randn(2500).reshape((50,50))

# define the colormap
cmap = plt.cm.jet
# extract all colors from the .jet map
cmaplist = [cmap(i) for i in range(cmap.N)]
# create the new map
cmap = cmap.from_list('Custom cmap', cmaplist, cmap.N)

# define the bins and normalize
bounds = np.linspace(np.min(a),np.max(a),5)
norm …

如何制作垂直直方图.有什么选择,还是应该从头开始构建？我想要的是上图看起来像下面的图,但在垂直轴上!

from matplotlib import pyplot as plt
import numpy as np
sample=np.random.normal(size=10000)
vert_hist=np.histogram(sample,bins=30)
ax1=plt.subplot(2,1,1)
ax1.plot(vert_hist[0],vert_hist[1][:-1],'*g')

ax2=plt.subplot(2,1,2)
ax2.hist(sample,bins=30)
plt.show()

假设我有一个功能:

def f():
  ...
  ...
  ...
  return a,b,c

我想在函数的输出中只得到b.我必须使用哪个作业？

谢谢.

我正在尝试实施贝叶斯网络.

我的主图是我想用于信念传播的因子图.但是,在计算消息时的置信传播中,并非所有参数都传递给函数,最终函数将是联合分布的限制.

我想到的最好的方法是以某种方式限制函数,以便每当我想为新值计算边际值时不进行所有替换.

我问过如何在这里实现这样的功能.

我想知道是否有更好的方法来做这样的事情,或者是否有比我想做的更简单快捷的方法.

我有一个由大量线条组成的情节.在每一步中,线条的颜色应该在动画中得到更新,但在线条上进行for循环似乎非常昂贵.有没有更好的方法呢？

这是我的代码:

import numpy as np
lines=[]
from matplotlib import pyplot as plt
import matplotlib.animation as animation

#initial plot
fig=plt.figure()
ax=plt.subplot(1,1,1)
for i in range(10):
    lines.append([])
    for j in range(10):
        lines[i].append(ax.plot([i,j],color='0.8'))
lines=np.asarray(lines)


##Updating the colors 10 times 
im=[]
for steps in range(10):
    colors=np.random.random(size=(10,10))
    for i in range(10):
        for j in range(10):
            lines[i,j][0].set_color(str(colors[i,j])) 
    plt.draw()
#    im.append(ax)
    plt.pause(.1)
#ani = animation.ArtistAnimation(fig, im, interval=1000, blit=True,repeat_delay=1000)
plt.show()

另外我无法与动画艺术家合作!我用画画.动画线有什么问题

现在将这些10增加到100会使程序非常缓慢:

import numpy as np
lines=[]
from matplotlib import pyplot as plt
import matplotlib.animation as animation …

在笛卡尔坐标系和n球坐标系之间有没有有效的改变方法？转型如下:

以下是我的代码,但我想摆脱循环:

import numpy as np
import scipy.sparse

    def coord_transform_n(r,alpha):
        """alpha: the n-2 values between [0,\pi) and last one between [0,2\pi)
        """
        x=[]
        for i in range(alpha.shape[0]):
            x.append(r*np.prod(np.sin(alpha[0:i]))*np.cos(alpha[i]))
        return np.asarray(x)
    print coord_transform_n(1,np.asarray(np.asarray([1,2])))

我试图在Numpy中进行线性组合以获得两点之间的向量遍历,但我正在做的方式非常可怕.

import numpy as np
a=np.array([1,2])
b=np.array([3,4])
t=np.linspace(0,1,4)
c=(np.asarray([t*a[0],t*a[1]])+np.asarray([(1-t)*b[0],(1-t)*b[1]])).T
print c

输出正在

[[ 3.          4.        ]
 [ 2.33333333  3.33333333]
 [ 1.66666667  2.66666667]
 [ 1.          2.        ]]

有没有更好的方法(当然有效)？

以下代码从具有不同间隔的trunctated正态分布生成大小为100的样本.这样做是否有任何有效(矢量化)方式？

from scipy.stats import truncnorm
import numpy as np
sample=[]
a_s=np.random.uniform(0,1,size=100)
b_s=a_s+0.2
for i in range(100):
    sample.append(truncnorm.rvs(a_s[i], b_s[i], size=100))
print sample

我有形状的2D阵列(M*N,N),其实际上包括M,N*N阵列.我想以N*N矢量化的方式转换所有这些元素(矩阵).举个例子,

import numpy as np
A=np.arange(1,28).reshape((9,3))
print "A before transposing:\n", A
for i in range(3):
    A[i*3:(i+1)*3,:]=A[i*3:(i+1)*3,:].T
print "A after transposing:\n", A

此代码生成以下输出:

A before transposing: 
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]
 [13 14 15]
 [16 17 18]
 [19 20 21]
 [22 23 24]
 [25 26 27]]
A after transposing: 
 [[ 1  4  7]
 [ 2  5  8]
 [ 3  6  9]
 [10 13 …

这是 R ⁿ中点的 K 最近邻算法，它应该计算每个点与其 k 最近邻的平均距离。问题是，虽然它是矢量化的，但从我重复自己的意义上说，它是低效的。如果有人可以帮助我改进此代码，我会很高兴：

import numpy as np
from scipy.spatial.distance import pdist
from scipy.spatial.distance import squareform

def nn_args_R_n_squared(points):
    """Calculate pairwise distances of points and return the matrix together with matrix of indices of the first matrix sorted"""
    dist_mat=squareform(pdist(points,'sqeuclidean'))
    return dist_mat,np.argsort(dist_mat,axis=1)
def knn_avg_dist(X,k):
    """Calculates for points in rows of X, the average distance of each, to their k-nearest      neighbours"""
    X_dist_mat,X_sorted_arg=nn_args_R_n_squared(X)
    X_matrices=(X[X_sorted_arg[:,1:k+1]]-X[...,None,...]).astype(np.float64)
    return np.mean(np.linalg.norm(X_matrices,axis=2)**2,axis=1)
X=np.random.randn(30).reshape((10,3))
print X
print knn_avg_dist(X,3)

输出：

[[-1.87979713  0.02832699  0.18654558]
 [ 0.95626677  0.4415187  -0.90220505]
 [ …