小编nei*_*nor的帖子

我是回归游戏的新手,希望为满足特定条件的数据子集绘制功能上任意的非线性回归线(加上置信度和预测区间)(即平均重复值超过阈值;见下文).

的data是为独立变量产生x跨越20点不同的值:x=(20-np.arange(20))**2与rep_num=10重复为每个条件.数据显示出强烈的非线性x,如下所示:

import numpy as np

mu = [.40, .38, .39, .35, .37, .33, .34, .28, .11, .24,
      .03, .07, .01, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]     

data = np.zeros((20, rep_num))
for i in range(13):
    data[i] = np.clip(np.random.normal(loc=mu[i], scale=0.1, size=rep_num), 0., 1.)

我可以制作数据的散点图; 重复方式由红点显示:

import matplotlib.pyplot as plt

plt.scatter(np.log10(np.tile(x[:,None], rep_num)), data, 
            facecolors='none', edgecolors='k', alpha=0.25)
plt.plot(np.log10(x), data.mean(1), 'ro', alpha=0.8)
plt.plot(np.log10(x), np.repeat(0., 20), 'k--')
plt.xlim(-0.02, np.max(np.log10(x)) + 0.02)
plt.ylim(-0.01, 0.7)

我的目标是仅为那些复制均值> …

对于2D索引的随机化数组中的每个元素(具有潜在的重复),我想要"+ = 1"到2D零数组中的相应网格.但是,我不知道如何优化计算.使用标准for循环,如此处所示,

def interadd():
    U = 100 
    input = np.random.random(size=(5000,2)) * U
    idx = np.floor(input).astype(np.int) 

    grids = np.zeros((U,U))      
    for i in range(len(input)):
        grids[idx[i,0],idx[i,1]] += 1
    return grids

运行时可能非常重要:

>> timeit(interadd, number=5000)
43.69953393936157

有没有办法对这个迭代过程进行矢量化？

我编写了一个函数模块,它接受两个变量的参数.为了情节,我有

x, y = pylab.ogrid[0.3:0.9:0.1, 0.:3.5:.5]
z = np.zeros(shape=(np.shape(x)[0], np.shape(y)[1]))

for i in range(len(x)):
    for j in range(len(y[0])):    
        z[i][j] = fancyFunction(x[i][0], y[0][j])

pylab.imshow(z, interpolation="gaussian")

我得到的图像如下:

但是当我尝试重新缩放x和y轴以匹配[0.3:0.9:0.1,0:3.5:5]的范围时,pylab.imshow(z, interpolation="gaussian", extent=[.3,.9,0.,3.5])我得到了

我一直在谷歌搜索几个小时,但仍然找不到一种方法来制作一个方形图与不同的缩放轴.

谢谢!

在我尝试对方差边界条件的2D阵列的方差 - 协方差矩阵执行cholesky分解时,在某些参数组合下,我总是得到LinAlgError: Matrix is not positive definite - Cholesky decomposition cannot be computed.不确定这是一个numpy.linalg问题还是实现问题,因为脚本很简单:

sigma = 3.
U = 4

def FromListToGrid(l_):
    i = np.floor(l_/U)
    j = l_ - i*U
    return np.array((i,j))

Ulist = range(U**2)

Cov = []
for l in Ulist:
    di = np.array([np.abs(FromListToGrid(l)[0]-FromListToGrid(i)[0]) for i, x in enumerate(Ulist)])
    di = np.minimum(di, U-di)

    dj = np.array([np.abs(FromListToGrid(l)[1]-FromListToGrid(i)[1]) for i, x in enumerate(Ulist)])
    dj = np.minimum(dj, U-dj)

    d = np.sqrt(di**2+dj**2)
    Cov.append(np.exp(-d/sigma))
Cov = np.vstack(Cov)

W = np.linalg.cholesky(Cov) …

我一直在寻找一个生成重叠时间序列图的解决方案,即http://grollchristian.files.wordpress.com/2013/04/wpid-224.png?w=604

但是,我在网上找到的唯一脚本是在R(上图)或Matlab中完成的.在matplotlib下我有什么选择？

对于2D晶格中的大量随机分布点,我想要有效地提取子阵列,该子阵列仅包含近似为索引的元素,这些元素被分配给单独的2D二进制矩阵中的非零值.目前,我的脚本如下:

lat_len = 100 # lattice length
input = np.random.random(size=(1000,2)) * lat_len
binary_matrix = np.random.choice(2, lat_len * lat_len).reshape(lat_len, -1)

def landed(input):
    output = []
    input_as_indices = np.floor(input)
    for i in range(len(input)):
        if binary_matrix[input_as_indices[i,0], input_as_indices[i,1]] == 1:
            output.append(input[i])
    output = np.asarray(output)
    return output   

但是,我怀疑必须有更好的方法来做到这一点.上面的脚本可能需要很长时间才能运行10000次迭代.

我使用此处给出的公式在Python中构建了一个包装的双变量高斯分布：http : //www.aos.wisc.edu/~dvimont/aos575/Handouts/bivariate_notes.pdf 但是，我不明白为什么我的分布不能求和尽管已包含归一化常数，但仍为1。

对于U x U晶格，

import numpy as np
from math import *

U = 60
m = np.arange(U)
i = m.reshape(U,1)
j = m.reshape(1,U)

sigma = 0.1
ii = np.minimum(i, U-i)
jj = np.minimum(j, U-j)
norm_constant = 1/(2*pi*sigma**2)
xmu = (ii-0)/sigma; ymu = (jj-0)/sigma
rhs = np.exp(-.5 * (xmu**2 + ymu**2))
ker = norm_constant * rhs

>> ker.sum() # area of each grid is 1 
15.915494309189533

我敢肯定，我在思考这个问题的方式上根本缺失了，并怀疑还需要某种额外的规范化，尽管我无法对此做出解释。

更新：

由于其他人的有深刻见解的建议，我重新编写了将L1标准化应用于内核的代码。但是，似乎在通过FFt进行2D卷积的情况下，将范围保持为[0，U]仍然可以返回令人信服的结果：

U = 100
Ukern = np.copy(U)
#Ukern …

我正在尝试使用matplotlib的pcolor函数实现等高线图,但是,似乎有一些与网格排列有关的细微规则以确保完全覆盖的图形.

为了显示:

a = arange(0., .8+.16, .16)
b = arange(0., .5+.10, .10)
A, B = meshgrid(a, b)
Z = A + B
pcolor(A,B,Z) 

这返回了数字

尽管shape(A)= shape(B)= 6.所以我的问题很简单:影响图右侧白色空间的是什么？如何删除它？谢谢.

给定具有未知函数形式的概率分布(下面的例子),我喜欢绘制"基于百分位数"的等高线,即那些对应于具有10%,20%,......,90%等积分的区域.

## example of an "arbitrary" probability distribution ##
from matplotlib.mlab import bivariate_normal
import matplotlib.pyplot as plt
import numpy as np

X, Y = np.mgrid[-3:3:100j, -3:3:100j]
z1 = bivariate_normal(X, Y, .5, .5, 0., 0.)
z2 = bivariate_normal(X, Y, .4, .4, .5, .5)
z3 = bivariate_normal(X, Y, .6, .2, -1.5, 0.)
z = z1+z2+z3
plt.imshow(np.reshape(z.T, (100,-1)), origin='lower', extent=[-3,3,-3,3])
plt.show()

我研究了多种方法,从使用matplotlib中的默认轮廓函数,在scipy中涉及stats.gaussian_kde的方法,甚至可能从分布中生成随机点样本并随后估计内核.他们似乎都没有提供解决方案.

给定一组离散位置(例如"站点"),它们以某些分类方式(例如一般接近度)成对相关并且包含局部级别数据(例如,种群大小),我希望有效地计算本地级别数据之间的平均相关系数.成对位置以相同的关系为特征.

例如,我假设100个站点并使用值1到25随机化它们的成对关系,产生三角矩阵relations:

import numpy as np

sites = 100
categ = 25

relations = np.random.randint(low=1, high=categ+1, size=(sites, sites))
relations = np.triu(relations) # set relation_ij = relation_ji
np.fill_diagonal(relations, 0) # ignore self-relation

我还在每个站点上复制了5000个模拟结果:

sims = 5000
res = np.round(np.random.rand(sites, sims),1)

要计算每个特定关系类别的平均成对相关,我首先计算出每个类别相关i,相关系数rho[j]的模拟结果之间的res每一个独特的网站对j,然后采取所有可能的对平均有关系i:

rho_list = np.ones(categ)*99

for i in range(1, categ+1):
    idr = np.transpose(np.where(relations == i)) # pairwise site indices of the same relation category
    comp = np.vstack([res[idr[:,0]].ravel(), res[idr[:,1]].ravel()]) …

这里相对编程新手来说。我很难弄清楚如何在一系列迭代中绘制插值函数，随着迭代索引的增加，绘图将从黑色逐渐变为浅灰色。

例如，

import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import interp1d

for t in np.arange(0.,2., 0.4):
    x = np.linspace(0.,4, 100)
    y = np.sin(x-2*t) + 0.01 * np.random.normal(size=x.shape)
    yint = interp1d(x, y)
    plt.plot(x, yint(x))

plt.show()

产生

我希望蓝色的正弦函数是黑色的，其余部分随着 t 的增加而变得更亮、更灰（向右）。我该怎么做呢？

感谢大家的慷慨帮助！

对于数据X = [0,0,1,1,0]和Y = [1,1,0,1,1]

>> np.corrcoef(X,Y) 

返回

array([[ 1.        , -0.61237244],
       [-0.61237244,  1.        ]])

但是，我无法使用np.var并np.cov给出http://docs.scipy.org/doc/numpy/reference/generated/numpy.corrcoef.html 中所示的方程来重现此结果：

>> np.cov([0,0,1,1,0],[1,1,0,1,1])/sqrt(np.var([0,0,1,1,0])*np.var([1,1,0,1,1]))

array([[ 1.53093109, -0.76546554],
       [-0.76546554,  1.02062073]])

这里发生了什么？

新手问题在这里.我很困惑为什么,只有在某些语法下,列表会在分配给它的其他列表得到更新时自动更新.例如,

如果我们将'a'分配给'b'并更新'b','a'仍然不受影响:

>>> b = [1,1,0]
>>> a = b
a = [1,1,0]
>>> b = [0,0,0]
a = [1,1,0]

但是,如果我们将最后一个更新命令重写为:

>>> b[:2] = [0]*2
a = [0,0,0] 

这是为什么？