NumPy: Генерация случайных чисел и случайная выборка элементов массива в Python

Генерация случайных чисел и выборка случайных элементов являются фундаментальными операциями во многих областях: от статистического моделирования и машинного обучения до тестирования программного обеспечения и криптографии. В Python библиотека NumPy предоставляет мощный и эффективный инструментарий для работы со случайностью, позволяя создавать как отдельные случайные значения, так и целые массивы данных с заданными распределениями.

Саммари статьи

ChatGPT

Google AI

Grok

Perplexity

В этой статье мы подробно рассмотрим различные методы генерации случайных чисел с плавающей точкой и целых чисел, а также способы случайной выборки элементов из существующих массивов и списков с использованием модуля numpy.random. Мы изучим функции, такие как rand(), randint(), uniform(), choice() и permutation(), предоставим практические примеры и обсудим лучшие практики для обеспечения воспроизводимости результатов.

Основы генерации случайности в NumPy

После того как мы убедились в фундаментальной роли случайных чисел в различных вычислительных задачах, пришло время рассмотреть, как NumPy подходит к их генерации. В основе всех операций со случайностью в этой библиотеке лежит модуль numpy.random, предоставляющий мощный и гибкий инструментарий.

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

Понятие псевдослучайности и модуль numpy.random

В мире компьютеров истинная случайность, как правило, недостижима. Вместо этого мы работаем с псевдослучайными числами. Это последовательности чисел, которые генерируются детерминированными алгоритмами, но при этом обладают статистическими свойствами, схожими с истинно случайными числами. Они выглядят случайными, но на самом деле полностью предсказуемы, если известен начальный параметр (так называемое "зерно" или "seed").

Для работы с псевдослучайностью в NumPy предназначен модуль numpy.random. Он предоставляет обширный набор функций для:

• Генерации случайных чисел с плавающей точкой.

• Генерации случайных целых чисел.

• Выборки случайных элементов из массивов или списков.

• Перемешивания элементов массива.

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

Воспроизводимость случайных чисел: использование numpy.random.seed()

Поскольку псевдослучайные числа генерируются детерминированным алгоритмом, их последовательность можно воспроизвести. Это критически важно для отладки кода, проведения повторяемых экспериментов и обеспечения согласованности результатов при совместной работе. Для достижения воспроизводимости в NumPy используется функция numpy.random.seed().

При вызове numpy.random.seed() с определенным целочисленным значением (seed) инициализируется внутреннее состояние генератора псевдослучайных чисел. Это означает, что каждый раз, когда вы используете одно и то же значение seed, последующие вызовы функций генерации случайных чисел будут производить одну и ту же последовательность.

import numpy as np

# Пример без seed
print("Без seed:")
print(np.random.rand(3))
print(np.random.rand(3))

# Пример с seed
print("\nС seed = 42:")
np.random.seed(42)
print(np.random.rand(3))
np.random.seed(42) # Повторный вызов с тем же seed
print(np.random.rand(3))

Как видно из примера, без seed каждый запуск программы или вызов функции rand() дает разные результаты. С использованием seed(42) последовательность чисел становится предсказуемой и одинаковой при каждом повторном запуске с тем же seed.

Генерация случайных чисел с плавающей точкой

После того как мы рассмотрели принципы псевдослучайности и важность обеспечения воспроизводимости с помощью numpy.random.seed(), пришло время перейти к практическим методам генерации случайных чисел. В этом разделе мы сосредоточимся на создании случайных чисел с плавающей точкой, которые являются основой для многих статистических симуляций, моделирования и задач машинного обучения. NumPy предоставляет несколько удобных функций для этой цели, позволяя генерировать как отдельные значения, так и целые массивы.

Мы рассмотрим, как получить случайные числа в стандартном диапазоне от 0 до 1, а также как легко масштабировать их для любого произвольного интервала. Понимание этих функций критически важно для эффективной работы с численными данными, требующими элемента случайности.

Создание чисел в диапазоне [0, 1) с numpy.random.rand() и numpy.random.sample()

Для начала работы с генерацией случайных чисел с плавающей точкой в диапазоне $[0, 1)$ (включая 0, но исключая 1) NumPy предлагает две основные функции: numpy.random.rand() и numpy.random.sample(). Обе функции ведут себя идентично, sample() является псевдонимом rand(). Они идеально подходят для базовых симуляций и статистических задач, где требуется равномерное распределение.

numpy.random.rand()

Эта функция генерирует случайные числа с плавающей точкой из стандартного равномерного распределения в полуоткрытом интервале $[0.0, 1.0)$.

• Генерация одного числа:

  import numpy as np
  
  random_float = np.random.rand()
  print(f"Одно случайное число: {random_float}")
  

• Генерация массива чисел заданной формы:

  Вы можете передать размеры массива в качестве отдельных аргументов.

  random_array_1d = np.random.rand(5) # 5 случайных чисел в 1D массиве
  print(f"Массив 1D: {random_array_1d}")
  
  random_array_2d = np.random.rand(2, 3) # Массив 2x3
  print(f"Массив 2D:\n{random_array_2d}")
  

numpy.random.sample()

Функция numpy.random.sample() работает точно так же, как numpy.random.rand(), принимая те же аргументы для определения формы выходного массива.

random_sample_float = np.random.sample()
print(f"Одно случайное число (sample): {random_sample_float}")

random_sample_array = np.random.sample((3, 2)) # Обратите внимание на кортеж для формы
print(f"Массив 2D (sample):\n{random_sample_array}")

Важно отметить, что rand() принимает размеры как отдельные аргументы, тогда как sample() (и большинство других функций в numpy.random) принимает форму как кортеж. Это небольшое, но важное различие в синтаксисе.

Генерация случайных чисел в заданном диапазоне с numpy.random.uniform()

Если вам требуется сгенерировать случайные числа с плавающей точкой не только в диапазоне [0, 1), но и в любом другом заданном интервале, на помощь приходит функция numpy.random.uniform(). Она позволяет указать нижнюю (low) и верхнюю (high) границы диапазона, а также размер (size) выходного массива.

Синтаксис функции: numpy.random.uniform(low=0.0, high=1.0, size=None)

• low: Нижняя (включительно) граница диапазона. По умолчанию 0.0.

• high: Верхняя (исключительно) граница диапазона. По умолчанию 1.0.

• size: Форма выходного массива. Если None, возвращается одно число.

Пример 1: Генерация одного числа в диапазоне [10, 20)

import numpy as np

random_float = np.random.uniform(low=10, high=20)
print(f"Случайное число в [10, 20): {random_float}")

Пример 2: Генерация массива 2×3 чисел в диапазоне [-5, 5)

random_array = np.random.uniform(low=-5, high=5, size=(2, 3))
print(f"Массив случайных чисел в [-5, 5):\n{random_array}")

Эта функция чрезвычайно полезна для симуляций, где требуются случайные величины, распределенные равномерно в определенном интервале.

Генерация случайных целых чисел

После того как мы освоили генерацию случайных чисел с плавающей точкой в различных диапазонах, логичным следующим шагом является работа со случайными целыми числами. Целые числа требуются не менее часто, чем дробные, например, для симуляции бросков кубика, выбора случайных индексов элементов массива, генерации ID или создания дискретных случайных событий. NumPy предлагает эффективные и интуитивно понятные инструменты для этой задачи.

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

Создание одного или нескольких случайных целых чисел с numpy.random.randint()

Для генерации случайных целых чисел в NumPy основной функцией является numpy.random.randint(). Она позволяет создавать как одно случайное целое число, так и массивы таких чисел в заданном диапазоне.

Синтаксис randint(low, high=None, size=None, dtype=int):

• low: Нижняя (включительно) граница диапазона.

• high: Верхняя (исключительно) граница диапазона. Если не указана, числа генерируются от 0 до low (исключительно).

• size: Форма выходного массива. Если None (по умолчанию), возвращается одно число.

• dtype: Тип данных результата.

Генерация одного случайного целого числа:

Чтобы получить одно случайное целое число, например, от 1 до 10 (включительно), используйте:

import numpy as np

случайное_число = np.random.randint(1, 11) # От 1 до 10 включительно
print(случайное_число)

Генерация массива случайных целых чисел:

Для создания массива из нескольких случайных целых чисел, укажите параметр size. Например, массив из 5 чисел от 0 до 9 (включительно):

массив_чисел = np.random.randint(0, 10, size=5)
print(массив_чисел)

Эта функция является мощным инструментом для симуляций, создания тестовых данных и других задач, требующих дискретной случайности.

Генерация массивов целых чисел в указанном диапазоне и форме

Функция numpy.random.randint() не ограничивается созданием одномерных массивов. С помощью параметра size можно легко генерировать многомерные массивы целых чисел, указывая желаемую форму (shape) массива.

Например, для создания матрицы 3×4, заполненной случайными целыми числами от 0 до 9 (не включая 10), синтаксис будет следующим:

import numpy as np

# Генерация матрицы 3x4 с числами от 0 до 9
matrix = np.random.randint(0, 10, size=(3, 4))
print("Матрица 3x4:\n", matrix)

Параметр size принимает кортеж, определяющий размеры каждой оси. Это позволяет создавать массивы любой сложности, например, трехмерный массив 2x3x2:

# Генерация 3D массива 2x3x2 с числами от 10 до 20
array_3d = np.random.randint(10, 21, size=(2, 3, 2))
print("\n3D массив 2x3x2:\n", array_3d)

Таким образом, randint() предоставляет гибкий инструмент для формирования массивов случайных целых чисел с заданной структурой, что крайне полезно для инициализации данных в симуляциях или моделях.

Случайная выборка элементов из массивов и списков

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

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

Выбор случайных элементов с numpy.random.choice() (с заменой и без)

Для случайной выборки элементов из существующего массива или списка NumPy предоставляет универсальную функцию numpy.random.choice(). Она позволяет выбирать один или несколько элементов, а также контролировать, могут ли выбранные элементы повторяться.

Выборка с заменой (с повторениями)

По умолчанию choice() выполняет выборку с заменой (т.е. с повторениями), что означает, что один и тот же элемент может быть выбран несколько раз. Это поведение задается аргументом replace=True.

import numpy as np

# Исходный массив
data = np.array([10, 20, 30, 40, 50])

# Выборка 3 элементов с заменой
sample_with_replacement = np.random.choice(data, size=3, replace=True)
print(f"Выборка с заменой: {sample_with_replacement}")
# Пример вывода: Выборка с заменой: [20 50 20]

Выборка без замены (без повторений)

Если необходимо выбрать уникальные элементы, используется выборка без замены. Для этого аргумент replace устанавливается в False. В этом случае каждый элемент может быть выбран только один раз.

# Выборка 3 элементов без замены
sample_without_replacement = np.random.choice(data, size=3, replace=False)
print(f"Выборка без замены: {sample_without_replacement}")
# Пример вывода: Выборка без замены: [40 10 30]

Важно отметить, что при выборке без замены (replace=False) параметр size не может превышать количество элементов в исходном массиве. Также choice() поддерживает взвешенную выборку с помощью аргумента p, позволяя задавать вероятности для каждого элемента.

Перемешивание (тасование) элементов массива с numpy.random.permutation()

В то время как numpy.random.choice() позволяет выбрать случайные элементы из массива, функция numpy.random.permutation() используется для случайного перемешивания (тасования) всего массива или создания случайной перестановки диапазона чисел. Она возвращает новую переставленную копию массива, не изменяя исходный.

Если permutation() передать целое число n, она вернет случайно переставленный массив np.arange(n).

import numpy as np

# Перемешивание диапазона чисел
perm_range = np.random.permutation(5) # Создаст перестановку [0, 1, 2, 3, 4]
print(f"Перестановка диапазона: {perm_range}")
# Пример вывода: Перестановка диапазона: [3 0 4 1 2]

# Перемешивание элементов существующего массива
arr = np.array([10, 20, 30, 40, 50])
shuffled_arr = np.random.permutation(arr)
print(f"Исходный массив: {arr}")
print(f"Перемешанный массив: {shuffled_arr}")
# Пример вывода:
# Исходный массив: [10 20 30 40 50]
# Перемешанный массив: [30 50 10 40 20]

numpy.random.permutation() особенно полезна в задачах, где требуется случайное упорядочивание данных, например, при подготовке обучающих и тестовых выборок в машинном обучении или при симуляции случайных событий.

Расширенные возможности и лучшие практики

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

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

Новый API numpy.random.Generator для современного подхода к случайности

Современный подход к генерации случайных чисел в NumPy представлен новым API numpy.random.Generator, который был введен в версии 1.17. Он предлагает более гибкий, объектно-ориентированный и статистически надежный способ работы со случайностью, заменяя устаревший модуль numpy.random.

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

Для создания экземпляра Generator используется функция numpy.random.default_rng(), которая по умолчанию инициализирует генератор с помощью алгоритма PCG64 — современного и высококачественного генератора псевдослучайных чисел.

import numpy as np

# Создание экземпляра генератора с возможностью установки seed
rng = np.random.default_rng(seed=42)

# Генерация чисел с плавающей точкой в диапазоне [0, 1)
float_numbers = rng.random(size=5)
print(f"Случайные числа с плавающей точкой: {float_numbers}")

# Генерация целых чисел в диапазоне [1, 10)
int_numbers = rng.integers(low=1, high=10, size=5)
print(f"Случайные целые числа: {int_numbers}")

# Случайная выборка элементов из массива (без замены)
data = np.array(['A', 'B', 'C', 'D', 'E'])
sample = rng.choice(data, size=3, replace=False)
print(f"Случайная выборка: {sample}")

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

Практические примеры применения случайных чисел в различных задачах

После знакомства с современным API numpy.random.Generator, давайте рассмотрим, как эти мощные инструменты применяются в реальных задачах. Случайные числа являются фундаментом для множества алгоритмов и симуляций.

Вот несколько практических примеров:

• Моделирование бросков кубика: Для симуляции 1000 бросков шестигранного кубика можно использовать rng.integers():

  import numpy as np
  rng = np.random.default_rng()
  броски_кубика = rng.integers(1, 7, size=1000)
  # print(броски_кубика[:10])
  

  Это позволяет быстро получить массив случайных целых чисел, имитирующих результаты бросков.

• Разделение данных на обучающую и тестовую выборки: В машинном обучении часто требуется случайным образом разделить набор данных. Предположим, у нас есть 1000 образцов:

  indices = np.arange(1000)
  rng.shuffle(indices) # Перемешиваем индексы
  train_size = int(0.8 * len(indices))
  train_indices = indices[:train_size]
  test_indices = indices[train_size:]
  # Теперь можно использовать train_indices и test_indices для выборки данных
  

  Здесь rng.shuffle() эффективно перемешивает массив индексов, обеспечивая случайное разделение.

• Инициализация весов нейронной сети: Часто веса нейронных сетей инициализируются малыми случайными числами, например, из равномерного или нормального распределения:

  веса_слоя = rng.uniform(-0.1, 0.1, size=(128, 64))
  # print(веса_слоя.shape)
  

  Это помогает избежать симметрии и способствует более эффективному обучению модели.

Заключение

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

Особое внимание было уделено воспроизводимости случайных процессов с помощью numpy.random.seed() и представлен современный подход через numpy.random.Generator. Понимание и умелое применение этих функций позволяет не только проводить точные симуляции, но и обеспечивать надежность и тестируемость ваших алгоритмов. NumPy предоставляет мощный и гибкий инструментарий для работы со случайностью, который является незаменимым в арсенале любого специалиста по данным.