从 np.empty 初始化 numpy 数组

Question

从空内存初始化 ndarray 时如何确定符号位？

>>> np.random.randn(3,3)
array([[-0.35557367, -0.0561576 , -1.84722985],
       [ 0.89342124, -0.50871646,  1.31368413],
       [ 0.0062188 ,  1.62968789,  0.72367089]])
>>> np.empty((3,3))
array([[0.35557367, 0.0561576 , 1.84722985],
       [0.89342124, 0.50871646, 1.31368413],
       [0.0062188 , 1.62968789, 0.72367089]])

这些从空内存初始化的浮点值已经失去了符号^†。这是为什么呢？

^†_{注意：这个结果依赖于内存重用的实现细节。问题询问实现在做什么。}

Answer 1

请记住，NumPy 是用 C（以及一些 Fortran、C++）编写的，答案可能与 Python 无关，我将尝试使用一些示例来说明正在发生的事情。多语言方面使这非常棘手，因此您可能需要在此处检查 np.empty() 函数的实现：https://github.com/numpy/numpy/blob/master/numpy/matlib.py#L13

你试过了吗：

import numpy as np

print(np.random.randn(3,3))
print(np.empty((3,3)))

我得到输出：（标志被保留）

[[-1.13898052  0.99079467 -0.07773854]
 [ 1.18519122  1.30324795 -0.38748375]
 [-1.46435162  0.53163777  0.22004651]]
[[-1.13898052  0.99079467 -0.07773854]
 [ 1.18519122  1.30324795 -0.38748375]
 [-1.46435162  0.53163777  0.22004651]]

您会注意到基于两件事的行为变化：

1. 是打印还是只输出值
2. 您创建了多少个空数组

例如，尝试运行以下两个示例：

# Run this over and over and you'll always get different results!

a = np.random.randn(3,3)
b = np.empty((3,3))
c = np.empty((3,3))
print(a, id(a)) # id gives memory address of array
print(b, id(b))
print(c, id(c))

带输出：

[[ 0.25754195  1.13184341 -0.46048928]
 [-0.80635852  0.92340661  2.08962923]
 [ 0.09552521  0.14940356  0.5644782 ]] 139865678073408
[[-1.63665076 -0.41916461  0.9251386 ]
 [ 2.72595838  0.10575355 -0.03555088]
 [ 0.71242678  0.09749262  0.24742165]] 139865678071568
[[-0.41824453  0.66565604  1.52995102]
 [ 0.8365397   0.32796832 -0.07150151]
 [-0.08558753  0.96326938 -0.56601338]] 139865678072688

对

# Run this 2 or more times and b and c will always be the same!

a = np.random.randn(3,3)
b = np.empty((3,3))
c = np.empty((3,3))
>>> a, id(a) # output without using print

(array([[-0.04230878,  0.18081425,  0.36880091],
    [ 0.4426956 , -1.31697583,  1.53143212],
    [ 0.58197615,  0.42028897,  0.27644022]]), 139865678070528)

>>> b, id(b)

(array([[-0.41824453,  0.66565604,  1.52995102],
    [ 0.8365397 ,  0.32796832, -0.07150151],
    [-0.08558753,  0.96326938, -0.56601338]]), 139865678048912)

>>> c, id(c) # c will have the same values as b!

(array([[-0.41824453,  0.66565604,  1.52995102],
    [ 0.8365397 ,  0.32796832, -0.07150151],
    [-0.08558753,  0.96326938, -0.56601338]]), 139865678069888)

尝试连续运行多次，以使内存有机会陷入某种模式。此外，根据您运行这两个块的顺序，您将获得不同的行为。

注意到当我们打印和不打印时“空”数组 b 和 c 的行为，我猜想使用输出会发生一种“惰性求值”，因为内存仍然是“空闲的”（即为什么 c 在上一个示例中得到与 b 相同的值），Python 没有义务为尚未实际分配内存的数组打印确切的值（malloc'd），即无符号表示，或者在您“使用”之前，任何事情都是公平的游戏。在我的示例中，我通过打印它来“使用”数组，这可以解释为什么在我的第一个示例中您会看到标记被打印保留。

Answer 2

numpy.empty 没有手动或任何清除符号位。符号位恰好是malloc 返回值的那些位中留下的任何垃圾。您看到的效果是由于在其他地方调用了numpy.absolute。

问题是，numpy.empty 没有重用randn 返回值的缓冲区。毕竟，由于_ 变量，empty 创建数组时，randn 返回值仍然存在。

numpy.empty 正在重用在字符串化第一个数组的过程中创建的数组的缓冲区。我相信是this one：

def fillFormat(self, data):
    # only the finite values are used to compute the number of digits
    finite_vals = data[isfinite(data)]

    # choose exponential mode based on the non-zero finite values:
    abs_non_zero = absolute(finite_vals[finite_vals != 0])
    ...

看到absolute 的电话了吗？就是这个。

以下是支持该结论的一些额外测试：

>>> a = numpy.random.randn(3, 3)
>>> b = numpy.arange(-5, 4, dtype=float)
>>> c = numpy.arange(-5, 13, 2, dtype=float)
>>> a
array([[-0.96810932,  0.86091026, -0.32675013],
       [-1.23458136,  0.56151178, -0.37409982],
       [-1.71348979,  0.64170792, -0.20679512]])
>>> numpy.empty((3, 3))
array([[ 0.96810932,  0.86091026,  0.32675013],
       [ 1.23458136,  0.56151178,  0.37409982],
       [ 1.71348979,  0.64170792,  0.20679512]])
>>> b
array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.])
>>> numpy.empty((3, 3))
array([[ 0.96810932,  0.86091026,  0.32675013],
       [ 1.23458136,  0.56151178,  0.37409982],
       [ 1.71348979,  0.64170792,  0.20679512]])
>>> c
array([ -5.,  -3.,  -1.,   1.,   3.,   5.,   7.,   9.,  11.])
>>> numpy.empty((3, 3))
array([[  5.,   3.,   1.],
       [  1.,   3.,   5.],
       [  7.,   9.,  11.]])
>>> numpy.array([1.0, 0, 2, 3, 4, 5, 6, 7, 8, 9])
array([ 1.,  0.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])
>>> numpy.empty((3, 3))
array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.],
       [ 7.,  8.,  9.]])

numpy.empty 结果受打印a 和c 影响，而不是受创建这些数组的过程影响。 b 没有效果，因为它有 8 个非零元素。最后的 array([1.0, 0, 2, ...]) 有效果，因为即使它有 10 个元素，其中也有 9 个是非零的。