小编Dan*_*iel的帖子

让我们从三个数组开始dtype=np.double.使用numpy 1.7.1在intel CPU上执行计时,编译icc并链接到intel mkl.带有numpy 1.6.1的AMD cpu与gccwithout 编译mkl也用于验证时序.请注意,时序与系统大小几乎呈线性关系,并不是由于numpy函数if语句中产生的小开销,这些差异将以微秒而非毫秒显示:

arr_1D=np.arange(500,dtype=np.double)
large_arr_1D=np.arange(100000,dtype=np.double)
arr_2D=np.arange(500**2,dtype=np.double).reshape(500,500)
arr_3D=np.arange(500**3,dtype=np.double).reshape(500,500,500)

首先让我们看一下这个np.sum函数:

np.all(np.sum(arr_3D)==np.einsum('ijk->',arr_3D))
True

%timeit np.sum(arr_3D)
10 loops, best of 3: 142 ms per loop

%timeit np.einsum('ijk->', arr_3D)
10 loops, best of 3: 70.2 ms per loop

鲍尔斯:

np.allclose(arr_3D*arr_3D*arr_3D,np.einsum('ijk,ijk,ijk->ijk',arr_3D,arr_3D,arr_3D))
True

%timeit arr_3D*arr_3D*arr_3D
1 loops, best of 3: 1.32 s per loop

%timeit np.einsum('ijk,ijk,ijk->ijk', arr_3D, arr_3D, arr_3D)
1 loops, best of 3: 694 ms per loop

外产品:

np.all(np.outer(arr_1D,arr_1D)==np.einsum('i,k->ik',arr_1D,arr_1D)) …

我需要一些关于python(scipy)中优化函数的帮助,问题是优化f(x)在哪里x=[a,b,c...n].约束是a,b等的值应该在0和1之间,并且sum(x)==1.scipy.optimise.minimize函数似乎最好,因为它不需要差异.我如何传递参数？

使用排列创建一个ndarray太长了.我现在的代码如下: -

import itertools as iter
all=iter.permutations([0.0,.1,.2,.3,.4,.5,.6,.7,.8,.9,1.0],6) if sum==1
all_legal=[]
for i in all:
if np.sum(i)==1:
    #print np.sum(i)
    all_legal.append(i)
print len(all_legal)
lmax=0
sharpeMax=0
for i in all_legal:
    if sharpeMax<getSharpe(i):
        sharpeMax=getSharpe(i)
        lmax=i

我正在构建一个脚本,为另一个要计算的程序生成输入数据[参数].我想优化结果数据.以前我一直在使用numpy powell优化.伪代码看起来像这样.

def value(param):
     run_program(param)
     #Parse output
     return value

scipy.optimize.fmin_powell(value,param) 

这很好用; 但是,它的速度非常慢,因为程序的每次迭代都需要几天才能运行.我想做的是粗粒并行化.因此,不是一次运行一次迭代,而是一次运行(参数数量)*2.例如:

Initial guess: param=[1,2,3,4,5]

#Modify guess by plus minus another matrix that is changeable at each iteration
jump=[1,1,1,1,1]
#Modify each variable plus/minus jump.
for num,a in enumerate(param):
    new_param1=param[:]
    new_param1[num]=new_param1[num]+jump[num]
    run_program(new_param1)
    new_param2=param[:]
    new_param2[num]=new_param2[num]-jump[num]
    run_program(new_param2)

#Wait until all programs are complete -> Parse Output
Output=[[value,param],...]
#Create new guess
#Repeat

变量的数量可以在3到12之间,所以像这样的东西可能会加速代码从一年减少到一周.所有变量都相互依赖,我只是从初始猜测中寻找局部最小值.我已经开始使用粗体矩阵的实现; 然而,这是非常复杂的.有没有什么可以做到这一点,有更简单的方法,或任何建议开始？

因此,主要问题如下:是否有一个算法采取初始猜测,生成多个猜测,然后使用这些多个猜测创建一个新的猜测,并重复,直到找到一个阈值.只有分析衍生物可用.有什么好办法解决这个问题,是否已经建立了这样的东西,还有其他选择吗？

感谢您的时间.

作为一个小更新,我确实通过计算每个维度的三个点的简单抛物线,然后使用最小值作为下一个猜测.这似乎工作得体,但不是最佳的.我还在寻找其他选择.

目前最好的实现是并行化powell方法的内循环.

谢谢大家的意见.不幸的是,似乎根本没有对这个特定问题的简明答案.如果我开始实现这样做的东西,我会把它贴在这里; 然而,由于项目不是特别重要或者需要结果,我可能会满足于让它占用节点一段时间.

I have an array and I would like to produce a smaller array by scanning a 2x2 non-overlappingly windows and getting the maximum. Here is an example:

import numpy as np

np.random.seed(123)
np.set_printoptions(linewidth=1000,precision=3)
arr = np.random.uniform(-1,1,(4,4))
res = np.zeros((2,2))
for i in xrange(res.shape[0]):
    for j in xrange(res.shape[1]):
        ii = i*2
        jj = j*2
        res[i][j] = max(arr[ii][jj],arr[ii+1][jj],arr[ii][jj+1],arr[ii+1][jj+1])

print arr
print res

So a matrix like this:

[[ 0.393 -0.428 -0.546  0.103]
 [ 0.439 -0.154  0.962  0.37 ]
 [-0.038 -0.216 -0.314  0.458] …

通过进行标准的Tornado演示并将IOLoop推入后台线程，可以在单个脚本中查询服务器。当Tornado服务器是交互式对象时，这很有用（请参阅Dask或类似内容）。

import asyncio
import requests
import tornado.ioloop
import tornado.web

from concurrent.futures import ThreadPoolExecutor

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

pool = ThreadPoolExecutor(max_workers=2)
loop = tornado.ioloop.IOLoop()

app = make_app()
app.listen(8888)
fut = pool.submit(loop.start)

print(requests.get("https://localhost:8888"))

上面的代码在标准python脚本中可以正常工作（尽管缺少安全关机）。Jupyter Notebook是这些交互式Tornado服务器环境的最佳环境。但是，当涉及到Jupyter时，由于已经存在一个活动的运行循环，所以这个想法失败了：

>>> import asyncio
>>> asyncio.get_event_loop()
<_UnixSelectorEventLoop running=True closed=False debug=False>

在Jupyter笔记本中运行上述脚本时，可以看到这一点，服务器和请求客户端都试图在同一线程中打开连接，并且代码挂起。建立一个新的Asyncio循环和/或Tornado IOLoop似乎没有帮助，我怀疑我在Jupyter本身中缺少了一些东西。

问题：Jupyter笔记本中是否可以在后台运行实时Tornado服务器，以便标准python requests或类似服务器可以从主线程连接到它？我希望尽可能避免在呈现给用户的代码中使用Asyncio，因为它对新手用户而言相对复杂。

我正在使用外部程序来计算用C++编写并与python通过接口的矩阵boost::python.我想把这个C数组传递给numpy,根据作者的说法,这个能力已经用numpy实现了obj.__array_interface__.如果我在python脚本中调用它并将C++对象分配给X我,我将获得以下内容:

print X
#<sprint.Matrix object at 0x107c5c320>

print X.__array_interface__
#<bound method Matrix.__array_interface__ of <sprint.Matrix object at 0x107c5c320>>

print X.__array_interface__()
#{'shape': (5, 5), 'data': (4416696960, True), 'typestr': '<f8'}

print np.array(X)
#Traceback (most recent call last):
#  File "<string>", line 96, in <module>
#ValueError: Invalid __array_interface__ value, must be a dict

从我有限的理解,我相信问题X.__array_interface__是没有实际上没有返回任何东西().有没有办法np.array明确地传递这些参数或解决此问题.

我真的很擅长混合C++和python,如果这没有意义,或者我需要在任何部分阐述让我知道!

我必须比较两个数字.其中一个来自custt python代码,另一个来自numpy.调试器显示它们具有相同的值'29 .0',但是第一个的float类型和第二个的类型是float64,所以a == b并且a - b == 0是False.我怎么处理它？有没有办法强制常规python变量默认float64使用或numpy使用float？

更新:最后所有这些值来自29.0写入的同一文件,因此我认为数值不存在差异.

假设我有一本__array_interface__字典，我想从字典本身创建该数据的 numpy 视图。例如：

buff = {'shape': (3, 3), 'data': (140546686381536, False), 'typestr': '<f8'}
view = np.array(buff, copy=False)

但是，这不适用于np.array将缓冲区或数组接口作为属性进行搜索。简单的解决方法可能如下：

class numpy_holder(object):
    pass

holder = numpy_holder()
holder.__array_interface__ = buff
view = np.array(holder, copy=False)

这看起来有点绕。我是否缺少一种直接的方法来做到这一点？

这是我在为样本熵编写python代码时遇到的问题.

map(max, abs(a[i]-a) ) 非常慢

还有其他功能表现更好map()吗？

andarray 在哪里看起来像np.array([ [1,2,3,4,5],[2,3,4,5,6],[3,4,5,3,2] ])

大家好我是python新手我必须为课堂作业实施套索L1回归.这涉及求解涉及块矩阵的二次方程.

minimize x^t * H * x  + f^t * x 
where x > 0

其中H是2×2块矩阵,其中每个元素是ak维矩阵,x和f是2×1矢量,每个元素是ak维矢量.

我在考虑使用ndarrays.

这样:

  np.shape(H) = (2, 2, k, k)
  np.shape(x) = (2, k)

但我发现np.dot(X,H)在这里不起作用.有没有简单的方法来解决这个问题？提前致谢.