相关疑难解决方法(0)

它是一个链表,一个数组？我四处搜寻,只发现有人在猜测.我的C知识不足以查看源代码.

我一直在尝试在导入pandas的AWS Lambda中运行我的代码.所以这就是我所做的.我有一个python文件,其中包含一个简单的代码如下(此文件具有lambda处理程序)

import json
print('Loading function')
import pandas as pd
def lambda_handler(event, context):
    return "Welcome to Pandas usage in AWS Lambda"

1. 我已将此python文件与numpy,pandas和pytz库一起压缩为部署包(在Amazon EC2 linux机器中完成所有这些)
2. 然后将包上传到S3
3. 创建了一个lambda函数(runtime = python3.6)并从S3上传了部署包

但是当我在AWS Lambda中测试lambda函数时,我得到以下错误:

Unable to import module 'lambda_function': Missing required dependencies ['numpy']

我已经在压缩包中有numpy,但我仍然得到这个错误.我试着按照Pandas和AWS Lambda给出的提示但没有运气.

有没有人遇到过同样的问题.非常感谢任何暗示或建议来解决这个问题.

谢谢

我想知道有没有简单的方法来使用python做几何意义但不使用python包.如果没有,是否有任何简单的包做几何意味着什么？

我在一组42000张图像上实现了一个称为TF-IDF的加权系统,每个图像包含784个像素.这基本上是42000乘784矩阵.

我尝试的第一种方法是使用显式循环并花费了超过2个小时.

def tfidf(color,img_pix,img_total):
    if img_pix==0:
        return 0
    else:
        return color * np.log(img_total/img_pix)

...

result = np.array([])
for img_vec in data_matrix:
    double_vec = zip(img_vec,img_pix_vec)
    result_row = np.array([tfidf(x[0],x[1],img_total) for x in double_vec])
    try:
        result = np.vstack((result,result_row))
    # first row will throw a ValueError since vstack accepts rows of same len
    except ValueError:
        result = result_row

我试图使用numpy矩阵的第二种方法花了不到5分钟.请注意,data_matrix,img_pix_mat都是42000 x 784矩阵,而img_total是标量.

result = data_matrix * np.log(np.divide(img_total,img_pix_mat))

我希望有人能解释速度上的巨大差异.

题为"NumPy数组:高效数值计算结构"(http://arxiv.org/pdf/1102.1523.pdf)的以下论文的作者在第4页的最上面指出,他们观察到500倍的速度提升由于矢量化计算.我假设我看到的速度增加很多是由于这个原因.但是,我想更进一步,问为什么numpy矢量化计算比标准python循环快得多？

另外,也许你们可能知道为什么第一种方法很慢的其他原因.尝试/除结构有高开销吗？或者为每个循环形成一个新的np.array需要很长时间？

谢谢.

在使用 Python 和 Numpy 实现一些 Gauss-Seidel 求解器时，我发现了一个有趣的副作用。我试图提取一些最小的例子：

    number = 1000
    startup = 'import numpy as np;N = 2048;X = np.arange(N * N).reshape((N, N));'
    startup2 = startup + 'np.empty_like(X)'


    example = ('X[1:: 2, : -1: 2] = ('
               'X[: -1: 2, 1:: 2] +'
               'X[1:: 2, : -1: 2] +'
               'X[1:: 2, : -1: 2] +'
               'X[: -1: 2, : -1: 2])/4')

print(timeit.timeit(example, setup=startup, number=number))在我的机器上运行~5s

而print(timeit.timeit(example, setup=startup2, number=number))需要~4s。

所以大约快 1 秒，尽管np.emtpy_like(X). 我在各种机器和各种数组大小或迭代中观察到了这种效果。

我假设分配中右侧的计算会导致时间数组分配。似乎 Numpy 以某种方式重用了创建的未使用数组np.emtpy_like(X) …

当我遇到作者陈述的句子时,我正在阅读"流利的Python " 这本书

如果你需要存储1000万个浮点值,那么数组效率要高得多,因为数组实际上并不包含完整的成熟对象,只有表示其机器值的压缩字节 - 就像C语言中的数组一样.

我无法理解作者试图传达的内容.他怎么说'压缩字节'？'压缩字节存储'是什么意思？.python列表如何存储它？为什么不以那种方式存储它,如果这是使它有效的？

我有两个2×2复杂矩阵数组，我想知道将它们相乘的最快方法是什么。（我想对矩阵数组的元素进行矩阵乘法。）目前，我有

numpy.array(map(lambda i: numpy.dot(m1[i], m2[i]), range(l)))

但是能做得更好吗？

谢谢，

v923z

试图了解python库是否已编译,因为我想知道我编写的解释代码是执行相同还是更差.

例如,我看到它在某处提到numpy和scipy是有效的,因为它们是编译的.我不认为这意味着字节码被编译,所以这是怎么做到的？它是用cython这样的东西编译成c的吗？或者它是使用像c这样的语言编写的,并以兼容的方式编译？

这是适用于所有模块还是根据具体情况而定？

如何快速找到数组中某行元素的最小或最大和？

例如：

1, 2
3, 4
5, 6
7, 8

最小和为第0行（1 + 2），最大和为第3行（7 + 8）

  print mat.shape
  (8, 1, 2)  
  print mat
 [[[-995.40045 -409.15112]]

 [[-989.1511  3365.3267 ]]

 [[-989.1511  3365.3267 ]]

 [[1674.5447  3035.3523 ]]

 [[   0.         0.     ]]

 [[   0.      3199.     ]]

 [[   0.      3199.     ]]

 [[2367.      3199.     ]]]

有人可以告诉我为什么这个Python Numpy代码:

import numpy as np
import time

k_max = 40000
N = 10000

data = np.zeros((2,N))
coefs = np.zeros((k_max,2),dtype=float)

t1 = time.time()
for k in xrange(1,k_max+1):
    cos_k = np.cos(k*data[0,:])
    sin_k = np.sin(k*data[0,:])
    coefs[k-1,0] = (data[1,-1]-data[1,0]) + np.sum(data[1,:-1]*(cos_k[:-1] - cos_k[1:]))
    coefs[k-1,1] = np.sum(data[1,:-1]*(sin_k[:-1] - sin_k[1:]))
t2 = time.time()

print('Time:')
print(t2-t1)

比这个C++代码更快:

#include <cstdio>
#include <iostream>
#include <cmath>
#include <time.h>

using namespace std;

// consts
const unsigned int k_max = 40000;
const unsigned int N = 10000;

int main()
{
    time_t …

我正在尝试使用Python处理大型2D数组，但速度非常慢。例如：

start = time.time()
result = numpy.empty([5000, 5000])

for i in range(5000):
    for j in range(5000):
        result[i, j] = (i * j) % 10

end = time.time()
print(end - start) # 8.8 s

Java中的相同程序要快得多：

long start = System.currentTimeMillis();
int[][] result = new int[5000][5000];

for (int i = 0; i < 5000; i++) {
    for (int j = 0; j < 5000; j++) {
        result[i][j] = (i * j) % 10;
    }
}

long end = System.currentTimeMillis();
System.out.println(end - start); // …