Инициализация массива numpy из np.empty

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.empty не очищает биты знака вручную или что-либо еще.Знаковые биты - это просто остатки мусора в тех битах возвращаемого значения malloc.Эффект, который вы видите, связан с вызовом numpy.absolute где-то еще.

Дело в том, что numpy.empty не использует повторно буфер возвращаемого значения randn.В конце концов, возвращаемое значение randn остается в силе, когда empty создает свой массив из-за переменной _.

numpy.empty повторно использует буфер массива, созданного в процессе строковый первый массив.Я полагаю, что это этот :

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 из них ненулевые.

Answer 2

Учитывая, что 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), то есть неподписанные представления, или что-то действительно является честной игрой, пока вы не «используете».В моих примерах я «использую» массив, печатая его, и это может объяснить, почему в моем первом примере вы видите, что знаки сохраняются при печати. ​​