相关疑难解决方法(0)

df = pd.DataFrame({'Col1': ['Bob', 'Joe', 'Bill', 'Mary', 'Joe'],
                   'Col2': ['Joe', 'Steve', 'Bob', 'Bob', 'Steve'],
                   'Col3': np.random.random(5)})

返回'Col1'和'Col2'的唯一值的最佳方法是什么？

期望的输出是

'Bob', 'Joe', 'Bill', 'Mary', 'Steve'

In [28]: arr = np.arange(16).reshape((2, 2, 4))

In [29]: arr
Out[29]: 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])


In [32]: arr.transpose((1, 0, 2))
Out[32]: 
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

当我们将一个整数元组传递给transpose()函数时,会发生什么？

具体来说,这是一个3D数组:当我传递轴的元组时,NumPy如何转换数组(1, 0 ,2)？你能解释一下这些整数所指的行或列吗？在NumPy的背景下,轴数是多少？

在numpy中,我们ndarray.reshape()用于重塑数组.

我注意到在pytorch中,人们使用torch.view(...)同样的目的,但同时也torch.reshape(...)存在.

所以我想知道他们和我应该使用其中任何一个之间的差异是什么？

就像在标题中一样,什么是连续的内存块？

根据这个SO和这个PyTorch讨论，PyTorch的view功能仅适用于连续内存，而reshape不能。在第二个链接中，作者甚至声称：

[ view] 将在非连续张量上引发错误。

但是张量什么时候有非连续内存呢？

numpy.array()中的order参数有什么作用？

它在文档中说我链接到它将指定数组的连续顺序,但我不知道这是什么意思.那么连续的顺序是什么？

订单参数文档的副本:

order:{'C','F','A'},可选指定数组的顺序.如果order是'C'(默认值),则数组将以C连续顺序排列(last-index变化最快).如果order为'F',则返回的数组将采用Fortran连续顺序(first-index变化最快).如果order是'A',则返回的数组可以是任何顺序(C-,Fortran-连续,甚至是不连续的).

我将数据连接到一个像这样的numpy数组:

xdata_test = np.concatenate((xdata_test,additional_X))

这已经完成了一千次.数组有dtype float32,它们的大小如下所示:

xdata_test.shape   :  (x1,40,24,24)        (x1 : [500~10500])   
additional_X.shape :  (x2,40,24,24)        (x2 : [0 ~ 500])

问题是当x1大于~2000-3000时,连接需要更长的时间.

下图显示了连接时间与x2维度大小的关系:

这是一个记忆问题还是numpy的基本特征？

我做了一些计算和测量的性能ufuncs喜欢np.cumsum在不同的轴,以使代码更高性能.

In [51]: arr = np.arange(int(1E6)).reshape(int(1E3), -1)

In [52]: %timeit arr.cumsum(axis=1)
2.27 ms ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [53]: %timeit arr.cumsum(axis=0)
4.16 ms ± 10.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

cumsum超过轴1的速度几乎比cumsum轴0 快2倍.为什么它会如此以及幕后发生了什么？能够清楚地了解其背后的原因是很好的.谢谢!

更新:经过一些研究后,我意识到如果有人正在构建一个总是只对某个轴求和的应用程序,那么应该按照适当的顺序初始化数组:即轴的C顺序 = 1和或Fortran-order for axis = 0 sums,以节省CPU时间.

另外:关于连续和非连续数组之间差异的这个优秀答案帮助了很多!

我有一个 1D 数组，需要将其扩展到 3D，并将原始数组复制到axis=0.

目前，我有这样的设置：

import numpy as np

x = np.array((1, 2, 3, 4, 5))
y = np.zeros((len(x), 5, 5))

for i in range(5):
  for j in range(5):
    y[:, i, j] = x

print(y)

[[[1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]
  [1. 1. 1. 1. 1.]]

 [[2. 2. 2. 2. 2.]
  [2. 2. 2. 2. 2.]
  [2. 2. 2. 2. 2.]
  [2. 2. 2. …

我遇到了这个问题，其中 np.diff 的 numba 实现在矩阵切片上不起作用。这是一个错误还是我做错了什么？

import numpy as np
from numba import njit
v = np.ones((2,2))
np.diff(v[:,0])

import numpy as np
from numba import njit
v = np.ones((2,2))
np.diff(v[:,0])

@njit
def numbadiff(x):
    return np.diff(x)

numbadiff(v[:,0])

最后一次调用返回错误，但我不知道为什么。