最近,我观察到熊猫的乘法速度更快。我在下面的示例中向您展示了这一点。在如此简单的操作上,这怎么可能呢?这怎么可能呢?pandas数据帧中的底层数据容器是numpy数组。
测量
我使用带形状(10k,10k)的数组/数据帧。
import numpy as np
import pandas as pd
a = np.random.randn(10000, 10000)
d = pd.DataFrame(a.copy())
a.shape
(10000, 10000)
d.shape
(10000, 10000)
%%timeit
d * d
53.2 ms ± 333 µs per loop
下面的python代码为一个numpy数组创建数据,我使用该数组在图上绘制一个单元框: box = np.array([[x, y] for x in np.arange(0.0, 1.01, 0.01) for y in
np.arange(0.0, 1.01, 0.01)]) 我想将box --向x分量添加一个数字,向y分量添加一个不同的数字--转换为另一个numpy数组,这样新的框就会出现在图中的其他位置。 我遇到了一些麻烦,我不知道我是否可以切片一个numpy数组来做我需要的加法,或者正确的循环语法是什么。 我的问题是:我怎么加,比如说每个x元素加1,每
当我执行两个数组a和b的成对乘法时,由于a的维数为100 x 200 x 3,而b的维数为100 x 200,我在numpy中得到了一个错误。但是,b只包含0和1s。如何将b的最后维数重复3次才能将b转换为100x200x3数组?
这与matlab中的爬虫类似。我基本上想要三份b的最后一个维度。我试过了np.tile(b, (1, 1, 3)),但是这产生了错误的维度。
我在Python中有两个numpy数组:
a = np.array(sorted(np.random.rand(6)*6)) # It is sorted.
b = np.array(np.random.rand(3)*6)
假设数组是
a = array([0.27148588, 0.42828064, 2.48130785, 4.01811243, 4.79403723, 5.46398145])
b = array([0.06231266, 1.64276013, 5.22786201])
我想要生成一个数组,其中包含a是<=的索引,而不是b中的每个元素,也就是说,我完全希望这样:
我正在努力理解numpy中的广播规则,但我注意到我首先需要很好地理解什么是一维numpy数组。我发现多个来源表明,一维numpy数组既不是水平向量,也不是垂直向量。因此,我期望它会根据所完成的操作和操作的其他组件而有所不同。但我真的找不到一维数组表现得像列向量的情况。例如:
a = np.arange(3)
b = np.arange(3)[:, np.newaxis]
a + b
array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4]])
这表明a的行为类似于水平向量。另一方面,如果我们把它加到水平矢量b上
a = np.arange(3)
b
h5py文档()说明如下:
重要的是,h5py不使用NumPy在写之前进行广播.
>>> dset2 = f.create_dataset("MyDataset", (1000,1000,1000), 'f')
>>> data = np.arange(1000*1000, dtype='f').reshape((1000,1000))
>>> dset2[:] = data # Does NOT allocate 3.8 G of memory
在这种情况下,广播指的是什么?
我需要帮助优化这个嵌套的for循环(python)。我在考虑利用numpy中的冒号表示法,但是我所有的尝试都导致了一些错误。
import numpy as np
board = np.random.rand(300, 300)
for i in range(300):
for j in range(300):
if (board[i,j] == 0):
if (np.random.randint(1000) == 1) : board[i,j] = 1
可以使用根据条件从两个数组中选择值:
import numpy
a = numpy.random.rand(5)
b = numpy.random.rand(5)
c = numpy.where(a > 0.5, a, b) # okay
但是,如果数组的维数更多,这将不再起作用:
import numpy
a = numpy.random.rand(5, 2)
b = numpy.random.rand(5, 2)
c = numpy.where(a[:, 0] > 0.5, a, b) # !
Traceback (most recent call last):
F
一个非常愚蠢的问题,但我想不出正确的方法。
A是2乘2矩阵,B是2×1矩阵。
在10个迭代循环中,B_new=A*B. B_new是2乘1。
每次迭代后将B_new保存到输出矩阵B_final中。最后,B_final是2乘10。
但是,在循环中将B添加到B_new有问题。下面是我的代码,有人能给我一些建议吗?
import numpy as np
a=np.ones(shape=(2,2))
b=np.ones(shape=(2,1))
c_final=np.zeros(shape=(2,10))
for i in range(0,10):
c=np.
我不明白。这些文档解释了广播的规则,但似乎没有用英语来定义它。我的猜测是,广播是当NumPy用虚拟数据填充一个较小的维度数组以执行操作时。但这不管用:
>>> x = np.array([1,3,5])
>>> y = np.array([2,4])
>>> x+y
*** ValueError: operands could not be broadcast together with shapes (3,) (2,)
但是,错误信息暗示我走在正确的轨道上。有人可以定义广播,然后提供一些简单的例子来说明什么时候起作用,什么时候不起作用?
我在Python中尝试了这个简单的例子。
import numpy as np
a = np.array([1,2,3,4])
b = np.array([20])
a + b # broadcasting takes place!
np.dot(a,b) # no broadcasting here?!
我认为np.dot也使用广播,但它似乎没有。
我想知道为什么这种行为背后的哲学是什么?
NumPy中哪些操作使用广播,哪些操作不使用广播?
是否有另一个版本的dot函数用于点积,
哪一种实际使用广播?
我有两个numpy数组,x of shape (m, 2)和y of shape (n, 2)。我想要计算(m, n, 2)数组,在位置(i, j)处,可以在out[i, j]处找到x[i]和y[j]的和。列表理解作品
import numpy
x = numpy.random.rand(13, 2)
y = numpy.random.rand(5, 2)
xy = numpy.array([
[xx + yy for yy in y]
for xx in x
])
但我想知道是否有一个更有效的解决方案通过numpy.add.outer或类似的东西。
numpy广播是如何工作的?
我的理解是:
两个阵列
one = np.random.rand(3,2)
two = np.random.rand(5,10)
为了通过数组one two减去数组one的每个条目,必须首先将数组one的每个条目转换为2d数组,如下所示
one_expanded = one[...,None,None]
然后,one_expanded可以直接减去two,得到预期的结果。
然而,基于我的理解,我无法理解numpy在下面两个示例中是如何工作的。
示例1
one = np.random.rand(3,2,1)
two = np.random.rand(2,10)
(on
我对NumPy相当陌生,所以很有可能我忽略了一些基本的东西。不要犹豫,问“愚蠢”的问题有关“基本”的事情!
我试着写一些函数来操纵向量。我希望它们能够处理单个向量,以及向量数组,就像大多数NumPy的实用程序一样:
import math
import numpy
def func(scalar, x, vector):
# arbitrary function
# I'm NOT looking to replace this with numpy.magic_sum_multiply()
# I'm trying to understand bro
术语描述了numpy如何在算术操作中处理不同形状的数组。
Example 1:
from numpy import array
a = array([1.0,2.0,3.0])
b = array([2.0,2.0,2.0]) # multiply element-by-element ()
a * b
>> array([ 2., 4., 6.])
Example 2 :
from numpy import array
a = array([1.0,2.0,3.0])
b = 2.0 # broadcast b to all a
a * b
>>arra
在numpy中,有没有一种快速的方法将向量添加到矩阵的每一行或每一列。
最近,我一直在将向量平铺到矩阵的大小,这可能会占用大量内存。例如
mat=np.arange(15)
mat.shape=(5,3)
vec=np.ones(3)
mat+=np.tile(vec, (5,1))
我能想到的另一种方法是使用python循环,但循环速度很慢:
for i in xrange(len(mat)):
mat[i,:]+=vec
在numpy中有没有一种快速的方法来做到这一点,而不用求助于C扩展?
如果能够虚拟平铺一个矢量,就像广播的一个更
我很难理解Numpy的阵列广播规则。
显然,如果你在两个尺寸和形状相同的数组上执行元素乘法,那么一切都很好。此外,如果你把多维数组乘以一个标量,它就能工作。这我能理解。
但是如果你有两个不同形状的N维数组,我不清楚广播规则到底是什么。这个解释说:为了广播,一个操作中两个数组的尾轴的大小必须是相同的,或者其中一个必须是一个。
好的,我假设尾轴是指N数组中的M x N。因此,这意味着如果我试图用相同的列数乘两个二维数组(矩阵),它应该能工作吗?只是它不..。
>>> from numpy import *
>>> A = array([[1,2],[3,4]])
假设我们有一个衣衫褴褛的嵌套序列,如下所示:
import numpy as np
x = np.ones((10, 20))
y = np.zeros((10, 20))
a = [[0, x], [y, 1]]
并希望创建一个完整的numpy数组,在必要时广播破烂的子序列(以匹配任何其他子序列的最大维数,在本例中为(10,20))。首先,我们可能尝试使用np.array(a),这会产生警告:
VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tup
我有两个矩阵A,B,NxKxD维,我想得到矩阵C,NxKxDxD维数,其中Cn,k= An,k,k.T (这里"x“表示维数Dx1和1xD的矩阵的乘积,所以结果必须是DxD维数),所以现在我的代码看起来如下(这里A=B= X):
def square(X):
out = np.zeros((N, K, D, D))
for n in range(N):
for k in range(K):
out[n, k] = np.dot(X[n, k, :, np.newaxis], X[n, k, np.newaxis, :])
我想知道如何获得与朱莉娅中的numpy.einsum类似的功能。
具体来说,我有一个三阶张量,我想把它乘以一个二阶张量(矩阵),收缩两个维度,得到一个一阶张量(向量)。
目前,我使用的是PyCall,所以我可以使用numpy.einsum函数,如下所示:
using PyCall
@pyimport numpy as np
a = rand(5,4,3)
b = rand(5,4)
c = np.einsum("ijk,ij", a,b)
size(c) == (3,)
依赖于调用python来做张量数学是有点愚蠢的。我还设想,julia实现将具有速度优势。然而,在朱莉娅中
我试图理解python乘法运算符。我总是假设它在执行以下操作时执行了一个点积
a * b
然而,下面的例子显示,产生了不同的形状。
a = np.random.random((3, 3))
b = np.array([1,0,1])
乘法运算符:
(a*b).shape
(3, 3)
Numpy点产品:
np.dot(a,b).shape
(3,)
乘法运算符在做什么数学运算?
我正在尝试使用NumPy和矢量化操作来让一段代码运行得更快。然而,我似乎对如何向量化这段代码有误解(可能是由于对向量化的不完全理解)。
以下是循环的工作代码(A和B是设置大小的2D数组,已经初始化):
for k in range(num_v):
B[:] = A[:]
for i in range(num_v):
for j in range(num_v):
A[i][j] = min(B[i][j], B[i][k] + B[k][j])
return A
下面是我对上述代码进行向量化的尝试:
for k in range(num_v