Задълбочено проучване на Python NumPy Random Sampling: Овладяване на статистическите разпределения

В обширната вселена на науката за данните и изчисленията, способността за генериране на случайни числа не е просто функция; тя е основен камък. От симулиране на сложни финансови модели и научни явления до обучение на алгоритми за машинно обучение и провеждане на стабилни статистически тестове, контролираната случайност е двигателят, който движи прозрението и иновациите. В сърцето на тази възможност в екосистемата на Python е NumPy, основният пакет за научни изчисления.

Докато много разработчици са запознати с вградения в Python модул `random`, функционалността за случайно семплиране на NumPy е мощна, предлагаща превъзходна производителност, по-широка гама от статистически разпределения и функции, предназначени за строгите изисквания на анализа на данни. Това ръководство ще ви отведе на задълбочено проучване на модула `numpy.random` на NumPy, преминавайки от основните принципи към овладяването на изкуството на семплиране от разнообразие от решаващи статистически разпределения.

Защо случайното семплиране има значение в света, управляван от данни

Преди да преминем към кода, важно е да разберем защо тази тема е толкова критична. Случайното семплиране е процесът на избиране на подмножество от индивиди от рамките на статистическа популация, за да се оцени характеристиката на цялата популация. В изчислителен контекст става въпрос за генериране на данни, които имитират конкретен процес от реалния свят. Ето няколко ключови области, където то е незаменимо:

• Симулация: Когато аналитично решение е твърде сложно, можем да симулираме процес хиляди или милиони пъти, за да разберем неговото поведение. Това е основата на методите на Монте Карло, използвани в области от физиката до финансите.
• Машинно обучение: Случайността е от решаващо значение за инициализирането на теглата на модела, разделянето на данните на обучаващи и тестови набори, създаването на синтетични данни за увеличаване на малки набори от данни и в алгоритми като Random Forests.
• Статистически изводи: Техники като bootstrapping и permutaion тестове разчитат на случайно семплиране, за да оценят несигурността на оценките и да тестват хипотези, без да правят силни предположения за основното разпределение на данните.
• A/B тестване: Симулирането на поведението на потребителите при различни сценарии може да помогне на бизнеса да оцени потенциалното въздействие на промяната и да определи необходимия размер на извадката за експеримент на живо.

NumPy предоставя инструментите за извършване на тези задачи с ефективност и прецизност, което го прави основно умение за всеки професионалист по данни.

Ядрото на случайността в NumPy: `Generator`

Модерният начин за работа с генериране на случайни числа в NumPy (от версия 1.17) е чрез класа `numpy.random.Generator`. Това е значително подобрение в сравнение със старите, наследени методи. За да започнете, първо създавате екземпляр на `Generator`.

Стандартната практика е да използвате `numpy.random.default_rng()`:

            import numpy as np

# Create a default Random Number Generator (RNG) instance
rng = np.random.default_rng()

# Now you can use this 'rng' object to generate random numbers
random_float = rng.random()
print(f"A random float: {random_float}")
            

              
                Copy
              
            
          

Старото срещу Новото: `np.random.RandomState` срещу `np.random.Generator`

Може да видите стар код, използващ функции директно от `np.random`, като `np.random.rand()` или `np.random.randint()`. Тези функции използват глобален, наследен екземпляр на `RandomState`. Въпреки че те все още работят за обратна съвместимост, модерният подход `Generator` е за предпочитане по няколко причини:

• По-добри статистически свойства: Новият `Generator` използва по-модерен и надежден алгоритъм за генериране на псевдо-случайни числа (PCG64), който има по-добри статистически свойства от стария Mersenne Twister (MT19937), използван от `RandomState`.
• Няма глобално състояние: Използването на експлицитен обект `Generator` (`rng` в нашия пример) избягва зависимостта от скрито глобално състояние. Това прави кода ви по-модулен, предвидим и по-лесен за отстраняване на грешки, особено в сложни приложения или библиотеки.
• Производителност и API: API на `Generator` е по-чист и често по-производителен.

Най-добра практика: За всички нови проекти винаги започвайте, като създавате екземпляр на генератор с `rng = np.random.default_rng()`.

Осигуряване на възпроизводимост: Силата на seed

Компютрите не генерират наистина случайни числа; те генерират псевдо-случайни числа. Те се създават от алгоритъм, който генерира последователност от числа, които изглеждат случайни, но всъщност са изцяло определени от начална стойност, наречена seed.

Това е фантастична функция за науката и развитието. Като предоставите един и същи seed на генератора, можете да сте сигурни, че ще получите абсолютно същата последователност от „случайни“ числа всеки път, когато стартирате кода си. Това е от решаващо значение за:

• Възпроизводими изследвания: Всеки може да възпроизведе резултатите ви точно.
• Отстраняване на грешки: Ако възникне грешка поради конкретна случайна стойност, можете да я възпроизведете постоянно.
• Справедливи сравнения: При сравняване на различни модели можете да гарантирате, че те са обучени и тествани върху едни и същи случайни разделения на данни.

Ето как задавате seed:

            # Create a generator with a specific seed
rng_seeded = np.random.default_rng(seed=42)

# This will always produce the same first 5 random numbers
print("First run:", rng_seeded.random(5))

# If we create another generator with the same seed, we get the same result
rng_seeded_again = np.random.default_rng(seed=42)
print("Second run:", rng_seeded_again.random(5))
            

              
                Copy
              
            
          

Основите: Прости начини за генериране на случайни данни

Преди да се потопим в сложни разпределения, нека обхванем основните градивни елементи, налични в обекта `Generator`.

Случайни числа с плаваща запетая: `random()`

Методът `rng.random()` генерира случайни числа с плаваща запетая в полуотворения интервал `[0.0, 1.0)`. Това означава, че 0.0 е възможна стойност, но 1.0 не е.

            # Generate a single random float
float_val = rng.random()
print(f"Single float: {float_val}")

# Generate a 1D array of 5 random floats
float_array = rng.random(size=5)
print(f"1D array: {float_array}")

# Generate a 2x3 matrix of random floats
float_matrix = rng.random(size=(2, 3))
print(f"2x3 matrix:\n{float_matrix}")
            

              
                Copy
              
            
          

Случайни цели числа: `integers()`

Методът `rng.integers()` е универсален начин за генериране на случайни цели числа. Той приема аргументи `low` и `high` за дефиниране на диапазона. Диапазонът включва `low` и изключва `high`.

            # Generate a single random integer between 0 (inclusive) and 10 (exclusive)
int_val = rng.integers(low=0, high=10)
print(f"Single integer: {int_val}")

# Generate a 1D array of 5 random integers between 50 and 100
int_array = rng.integers(low=50, high=100, size=5)
print(f"1D array of integers: {int_array}")

# If only one argument is provided, it's treated as the 'high' value (with low=0)
# Generate 4 integers between 0 and 5
int_array_simple = rng.integers(5, size=4)
print(f"Simpler syntax: {int_array_simple}")
            

              
                Copy
              
            
          

Семплиране от собствените ви данни: `choice()`

Често не искате да генерирате числа от нулата, а по-скоро да семплирате от съществуващ набор от данни или списък. Методът `rng.choice()` е идеален за това.

            # Define our population
options = ["apple", "banana", "cherry", "date", "elderberry"]

# Select one random option
single_choice = rng.choice(options)
print(f"Single choice: {single_choice}")

# Select 3 random options (sampling with replacement by default)
multiple_choices = rng.choice(options, size=3)
print(f"Multiple choices (with replacement): {multiple_choices}")

# Select 3 unique options (sampling without replacement)
# Note: size cannot be larger than the population size
unique_choices = rng.choice(options, size=3, replace=False)
print(f"Unique choices (without replacement): {unique_choices}")

# You can also assign probabilities to each choice
probabilities = [0.1, 0.1, 0.6, 0.1, 0.1] # 'cherry' is much more likely
weighted_choice = rng.choice(options, p=probabilities)
print(f"Weighted choice: {weighted_choice}")
            

              
                Copy
              
            
          

Изследване на ключови статистически разпределения с NumPy

Сега стигаме до ядрото на мощността на случайното семплиране на NumPy: способността да се черпят извадки от голямо разнообразие от статистически разпределения. Разбирането на тези разпределения е от основно значение за моделиране на света около нас. Ще покрием най-често срещаните и полезни.

Равномерно разпределение: Всеки резултат е еднакъв

Какво представлява: Равномерното разпределение е най-простото. То описва ситуация, при която всеки възможен резултат в непрекъснат диапазон е еднакво вероятен. Помислете за идеализиран въртящ се диск, който има еднакъв шанс да падне на всеки ъгъл.

Кога да го използвате: Често се използва като начална точка, когато нямате предварителни познания, които да благоприятстват един резултат пред друг. Освен това е основата, от която често се генерират други, по-сложни разпределения.

NumPy функция: `rng.uniform(low=0.0, high=1.0, size=None)`

            # Generate 10,000 random numbers from a uniform distribution between -10 and 10
uniform_data = rng.uniform(low=-10, high=10, size=10000)

# A histogram of this data should be roughly flat
import matplotlib.pyplot as plt

plt.hist(uniform_data, bins=50, density=True)
plt.title("Uniform Distribution")
plt.xlabel("Value")
plt.ylabel("Probability Density")
plt.show()
            

              
                Copy
              
            
          

Нормално (Гаусово) разпределение: Кривата на камбаната

Какво представлява: Може би най-важното разпределение във всички статистически данни. Нормалното разпределение се характеризира със своята симетрична, камбановидна крива. Много природни явления, като човешки ръст, грешки при измерване и кръвно налягане, са склонни да следват това разпределение поради Централната гранична теорема.

Кога да го използвате: Използвайте го, за да моделирате всеки процес, при който очаквате стойностите да се групират около централна средна стойност, като крайните стойности са редки.

NumPy функция: `rng.normal(loc=0.0, scale=1.0, size=None)`

• `loc`: Средната стойност („център“) на разпределението.
• `scale`: Стандартното отклонение (колко разпръснато е разпределението).

            # Simulate adult heights for a population of 10,000
# Assume a mean height of 175 cm and a standard deviation of 10 cm
heights = rng.normal(loc=175, scale=10, size=10000)

plt.hist(heights, bins=50, density=True)
plt.title("Normal Distribution of Simulated Heights")
plt.xlabel("Height (cm)")
plt.ylabel("Probability Density")
plt.show()
            

              
                Copy
              
            
          

Специален случай е Стандартно нормално разпределение, което има средна стойност 0 и стандартно отклонение 1. NumPy предоставя удобен пряк път за това: `rng.standard_normal(size=None)`.

Биномиално разпределение: Серия от „Да/Не“ опити

Какво представлява: Биномиалното разпределение моделира броя на „успехите“ в фиксиран брой независими опити, където всеки опит има само два възможни резултата (напр. успех/неуспех, глава/тура, да/не).

Кога да го използвате: За моделиране на сценарии като броя глави в 10 преобръщания на монета, броя на дефектните елементи в партида от 50 или броя на клиентите, които кликват върху реклама от 100 зрители.

NumPy функция: `rng.binomial(n, p, size=None)`

• `n`: Броят на опитите.
• `p`: Вероятността за успех в един опит.

            # Simulate flipping a fair coin (p=0.5) 20 times (n=20)
# and repeat this experiment 1000 times (size=1000)
# The result will be an array of 1000 numbers, each representing the number of heads in 20 flips.
num_heads = rng.binomial(n=20, p=0.5, size=1000)

plt.hist(num_heads, bins=range(0, 21), align='left', rwidth=0.8, density=True)
plt.title("Binomial Distribution: Number of Heads in 20 Coin Flips")
plt.xlabel("Number of Heads")
plt.ylabel("Probability")
plt.xticks(range(0, 21, 2))
plt.show()
            

              
                Copy
              
            
          

Разпределение на Poisson: Преброяване на събития във времето или пространството

Какво представлява: Разпределението на Poisson моделира броя на пътите, когато дадено събитие се случва в рамките на определен интервал от време или пространство, предвид това, че тези събития се случват с известна постоянна средна скорост и са независими от времето след последното събитие.

Кога да го използвате: За моделиране на броя на пристигащите клиенти в магазин за час, броя на правописните грешки на страница или броя на обажданията, получени от кол център за минута.

NumPy функция: `rng.poisson(lam=1.0, size=None)`

• `lam` (lambda): Средната скорост на събитията на интервал.

            # A cafe receives an average of 15 customers per hour (lam=15)
# Simulate the number of customers arriving each hour for 1000 hours
customer_arrivals = rng.poisson(lam=15, size=1000)

plt.hist(customer_arrivals, bins=range(0, 40), align='left', rwidth=0.8, density=True)
plt.title("Poisson Distribution: Customer Arrivals per Hour")
plt.xlabel("Number of Customers")
plt.ylabel("Probability")
plt.show()
            

              
                Copy
              
            
          

Експоненциално разпределение: Времето между събитията

Какво представлява: Експоненциалното разпределение е тясно свързано с разпределението на Poisson. Ако събитията се случват според процес на Poisson, тогава времето между последователните събития следва експоненциално разпределение.

Кога да го използвате: За моделиране на времето до пристигането на следващия клиент, продължителността на живота на крушка или времето до следващото радиоактивно разпадане.

NumPy функция: `rng.exponential(scale=1.0, size=None)`

• `scale`: Това е обратната стойност на параметъра на скоростта (lambda) от разпределението на Poisson. `scale = 1 / lam`. Така че, ако скоростта е 15 клиенти на час, средното време между клиентите е 1/15 от час.

            # If a cafe receives 15 customers per hour, the scale is 1/15 hours
# Let's convert this to minutes: (1/15) * 60 = 4 minutes on average between customers
scale_minutes = 4
time_between_arrivals = rng.exponential(scale=scale_minutes, size=1000)

plt.hist(time_between_arrivals, bins=50, density=True)
plt.title("Exponential Distribution: Time Between Customer Arrivals")
plt.xlabel("Minutes")
plt.ylabel("Probability Density")
plt.show()
            

              
                Copy
              
            
          

Lognormal Distribution: Когато логаритъмът е нормален

Какво представлява: Lognormal distribution е непрекъснато разпределение на вероятностите на случайна променлива, чийто логаритъм е нормално разпределен. Получената крива е дясно изкривена, което означава, че има дълга опашка надясно.

Кога да го използвате: Това разпределение е отлично за моделиране на количества, които винаги са положителни и чиито стойности обхващат няколко порядъка. Често срещаните примери включват личен доход, цени на акции и градско население.

NumPy функция: `rng.lognormal(mean=0.0, sigma=1.0, size=None)`

• `mean`: Средната стойност на основното нормално разпределение (не средната стойност на lognormal output).
• `sigma`: Стандартното отклонение на основното нормално разпределение.

            # Simulate income distribution, which is often log-normally distributed
# These parameters are for the underlying log scale
income_data = rng.lognormal(mean=np.log(50000), sigma=0.5, size=10000)

plt.hist(income_data, bins=100, density=True, range=(0, 200000)) # Cap range for better viz
plt.title("Lognormal Distribution: Simulated Annual Incomes")
plt.xlabel("Income")
plt.ylabel("Probability Density")
plt.show()
            

              
                Copy
              
            
          

Практически приложения в науката за данни и отвъд

Разбирането как да генерирате тези данни е само половината от битката. Истинската сила идва от прилагането му.

Симулация и моделиране: Методи на Монте Карло

Представете си, че искате да оцените стойността на Pi. Можете да направите това със случайно семплиране! Идеята е да впишете окръжност в квадрат. След това генерирайте хиляди случайни точки в квадрата. Съотношението на точките, които попадат в окръжността, към общия брой точки е пропорционално на съотношението на площта на окръжността към площта на квадрата, което може да се използва за решаване на Pi.

Това е прост пример за метод на Монте Карло: използване на случайно семплиране за решаване на детерминистични проблеми. В реалния свят това се използва за моделиране на риска на финансовото портфолио, физиката на частиците и сложни графици на проекти.

Основи на машинното обучение

В машинното обучение контролираната случайност е навсякъде:

• Инициализация на тегла: Теглата на невронната мрежа обикновено се инициализират с малки случайни числа, извлечени от нормално или равномерно разпределение, за да се наруши симетрията и да се позволи на мрежата да се учи.
• Увеличаване на данните: За разпознаване на изображения можете да създадете нови обучаващи данни, като приложите малки случайни завъртания, измествания или промени в цвета към съществуващите изображения.
• Синтетични данни: Ако имате малък набор от данни, понякога можете да генерирате нови, реалистични точки от данни, като семплирате от разпределения, които моделират вашите съществуващи данни, като помагате да се предотврати прекомерното прилягане.
• Регуларизация: Техники като Dropout случайно деактивират част от невроните по време на обучение, за да направят мрежата по-стабилна.

A/B тестване и статистически изводи

Да предположим, че провеждате A/B тест и установявате, че новият дизайн на уебсайта има с 5% по-висок процент на реализация. Това реално подобрение ли е или просто случайна късмет? Можете да използвате симулация, за да разберете. Като създадете две биномиални разпределения със същия основен процент на реализация, можете да симулирате хиляди A/B тестове, за да видите колко често се случва разлика от 5% или повече само случайно. Това помага за изграждането на интуиция за концепции като p-стойности и статистическа значимост.

Най-добри практики за случайно семплиране във вашите проекти

За да използвате тези инструменти ефективно и професионално, имайте предвид тези най-добри практики:

1. Винаги използвайте модерния генератор: Започнете скриптовете си с `rng = np.random.default_rng()`. Избягвайте старите функции `np.random.*` в новия код.
2. Seed за възпроизводимост: За всеки анализ, експеримент или доклад, seed вашия генератор (`np.random.default_rng(seed=...)`). Това е незаобиколимо за надеждна и проверима работа.
3. Изберете правилното разпределение: Отделете време, за да помислите за процеса от реалния свят, който моделирате. Серия от да/не опити ли е (Биномиално)? Времето между събития ли е (Експоненциално)? Това мярка, която се групира около средна стойност ли е (Нормална)? Правилният избор е критичен за смислена симулация.
4. Използвайте векторизация: NumPy е бърз, защото извършва операции върху цели масиви наведнъж. Генерирайте всички случайни числа, от които се нуждаете, с едно извикване (използвайки параметъра `size`), а не в цикъл.
5. Визуализирайте, визуализирайте, визуализирайте: След генериране на данни, винаги създавайте хистограма или друга графика. Това предоставя бърза проверка на здравия разум, за да се гарантира, че формата на данните съответства на разпределението, от което сте възнамерявали да семплирате.

Заключение: От случайността към прозрение

Преминахме от основната концепция за генератор на случайни числа със seed към практическото приложение на семплиране от разнообразен набор от статистически разпределения. Овладяването на модула `random` на NumPy е повече от техническо упражнение; става въпрос за отключване на нов начин за разбиране и моделиране на света. Той ви дава силата да симулирате системи, да тествате хипотези и да изграждате по-стабилни и интелигентни модели за машинно обучение.

Способността да се генерират данни, които имитират реалността, е основно умение в инструментариума на съвременния учен за данни. Като разбирате свойствата на тези разпределения и мощните, ефективни инструменти, които NumPy предоставя, можете да преминете от прост анализ на данни към сложни моделиране и симулация, превръщайки структурираната случайност в дълбоко прозрение.