Как могут отличаться эти альтернативные конструкции `uniform` и `random`?

Я запустил ваш код со следующими значениями:

seed = 0
target_shape = [100]
vector_size = 3

Я заметил, что код в вашем первом решении сгенерировал новые_векторы, отличные от вашего второго решения.

В частности, похоже, что uniform сохраняет половину значений из генератора случайных чисел, которые random делает с тем же начальным числом. Вероятно, это связано с деталями реализации в генераторе случайных чисел из numpy.

В следующем фрагменте я вставил только пробелы, чтобы выровнять похожие значения. вероятно, также происходит некоторое округление с плавающей запятой, из-за чего результат кажется не идентичным.

[            0.09130779,              -0.15347552,             -0.30601767,              -0.32231492,              0.20884682, ...]
[0.23374946, 0.09130772, 0.007424275, -0.1534756, -0.12811375, -0.30601773, -0.28317323, -0.32231498, -0.21648853, 0.20884681, ...]

Основываясь на этом, я предполагаю, что ваш стохастический тестовый пример проверяет ваше решение только с одним начальным числом и потому, что вы создаете другую последовательность с новым решением. и этот результат вызывает сбой в тестовом примере.

Способ поддерживать точность и экономить память может состоять в том, чтобы создать большой целевой массив, а затем заполнить его, используя блоки с более высокой точностью.

Например:

def generate(shape, value, *, seed=None, step=10):
  arr = np.empty(shape, dtype=np.float32)
  rng = np.random.default_rng(seed=seed)
  (d0, *dr) = shape
  for i in range(0, d0, step):
    j = min(d0, i + step)
    arr[i:j,:] = rng.uniform(-1/value, 1/value, size=[j-i]+dr)
  return arr

который можно использовать как:

generate((100, 1024, 1024), 7, seed=13)

Вы можете настроить размер этих блоков (через step) для поддержания производительности.

Выведем new_vectors * 2**22 % 1 для обоих методов, т.е. посмотрим, что осталось после первых 22 дробных бит (программа в конце). С первым методом:

[[0.         0.5        0.25       0.         0.        ]
 [0.5        0.875      0.25       0.         0.25      ]
 [0.         0.25       0.         0.5        0.5       ]
 [0.6875     0.328125   0.75       0.5        0.52539062]
 [0.75       0.75       0.25       0.375      0.25      ]]

Со вторым методом:

[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]

Большая разница! Второй метод не создает чисел с 1 битами после первых 22 дробных битов.

Давайте представим, что у нас есть тип float3, который может содержать только три значащих бита (подумайте о диапазоне ненулевых битов), например числа (в двоичном формате) 1,01, 11100,0 или 0,0000111, но не 10,01, потому что имеет четыре значащих бита.

Затем генератор случайных чисел для диапазона [0, 1) выберет из этих восьми чисел:

0.000
0.001
0.010
0.011
0.100
0.101
0.110
0.111

Сейчас подожди. Почему только из этих восьми? Как насчет, например, вышеупомянутого 0,0000111? Это в [0, 1) и может быть представлено, верно?

Ну да, но обратите внимание, что это в [0, 0,5). Кроме того, нет дополнительных представленных чисел в диапазоне [0,5, 1), так как все эти числа начинаются с 0,1, и, следовательно, любые дальнейшие 1-биты могут быть только во втором или третьем дробном бите. Например, число 0,1001 невозможно представить, так как оно содержит четыре значащих бита.

Таким образом, если бы генератор также выбирал из любых других чисел, кроме тех восьми, что указаны выше, все они должны были бы находиться в диапазоне [0, 0,5], что создавало бы смещение. Вместо этого он может выбрать из разных четырех чисел в этом диапазоне или, возможно, включить все представимые числа в этом диапазоне с соответствующими вероятностями, но в любом случае у вас будет смещение зазора, где числа, выбранные из [0, 0,5), могут иметь меньшие или большие пробелы, чем числа, выбранные из [0,5, 1). Не уверен, что смещение разрыва — это вещь или правильный термин, но дело в том, что распределение в [0, 0,5) будет выглядеть иначе, чем в [0,5, 1). Единственный способ сделать так, чтобы они выглядели одинаково, — это выбрать из этих восьми чисел, расположенных на одинаковом расстоянии друг от друга выше. Распределение/возможности в [0.5, 1) определяют, что вы должны использовать в [0, 0.5).

Итак... генератор случайных чисел для float3 выберет из этих восьми чисел и никогда не сгенерирует, например, 0,0000111. А теперь представьте, что у нас также есть тип float5, который может содержать пять значащих битов. Затем генератор случайных чисел для этого может выбрать 0,00001. И если вы затем преобразуете это в наше float3, это сохранится, у вас будет 0,00001 как float3. Но в диапазоне [0,5, 1) этот процесс генерации float5 чисел и преобразования их в float3 по-прежнему будет давать только числа 0,100, 0,101, 0,110 и 0,111, поскольку float3 по-прежнему не может представлять никакие другие числа в этом диапазоне.

Вот что вы получите, только с float32 и float64. Ваши два метода дают вам разные дистрибутивы. Я бы сказал, что распределение второго метода на самом деле лучше, так как у первого метода есть то, что я назвал смещением разрыва. Так что, возможно, сломался не ваш новый метод, а тест. Если это так, исправьте тест. В противном случае идея исправить вашу ситуацию может состоять в том, чтобы использовать старый способ float64-to-float32, но не производить все сразу. Вместо этого подготовьте структуру float32, используя везде только 0.0, а затем заполните ее меньшими фрагментами, сгенерированными по-новому.

Небольшое предостережение, кстати: похоже, в NumPy есть ошибка для генерации случайных значений float32, не используя самый младший бит. Так что это может быть еще одной причиной провала теста. Вы можете попробовать второй метод с (rng.integers(0, 2**24, target_shape) / 2**24).astype(np.float32) вместо rng.random(target_shape, dtype=np.float32). Я думаю, что это эквивалентно тому, что было бы в исправленной версии (поскольку, по-видимому, в настоящее время это делается именно так, за исключением 23 вместо 24).

Программа для эксперимента вверху (также на repl.it):

import numpy as np

# Some setup
seed = 13
target_shape = (5, 5)
vector_size = 1

# First way
rng = np.random.default_rng(seed=seed)
new_vectors = rng.uniform(-1.0, 1.0, target_shape).astype(np.float32)  # [-1.0, 1.0)
new_vectors /= vector_size

print(new_vectors * 2**22 % 1)

# Second way
rng = np.random.default_rng(seed=seed)
new_vectors = rng.random(target_shape, dtype=np.float32)  # [0.0, 1.0)                                                 
new_vectors *= 2.0  # [0.0, 2.0)                                                                                  
new_vectors -= 1.0  # [-1.0, 1.0)
new_vectors /= vector_size

print(new_vectors * 2**22 % 1)