Математика для нейронного обучения

Глава 9. РАСПРЕДЕЛЕНИЯ ВЕРОЯТНОСТЕЙ

9.1. Распределение Бернулли

$$P(X=x)=p^x(1-p{)}^{1-x},x\in \{0,1\},0\le p\le 1$$

Объяснение: Распределение Бернулли моделирует одно бинарное событие (испытание) с вероятностью успеха $p$.

Пример: Для $p=0.7$, $P(X=1)=0.7$, $P(X=0)=1-0.7=0.3$.

Реализация (используя scipy.stats):

from scipy.stats import bernoulli

p_success = 0.7
# Вычисление P(X=1)
prob_1 = bernoulli.pmf(k=1, p=p_success)
# Вычисление P(X=0)
prob_0 = bernoulli.pmf(k=0, p=p_success)

print(f"P(X=1) for p={p_success}: {prob_1}")
print(f"P(X=0) for p={p_success}: {prob_0}")

9.2. Биномиальное распределение

$$P(X=k)=(\genfrac{}{}{0ex}{}{n}{k})p^k(1-p{)}^{n-k},k\in \{0,1,\dots ,n\}$$ (где $(\genfrac{}{}{0ex}{}{n}{k})=\frac{n!}{k!(n-k)!}$ - биномиальный коэффициент)

Объяснение: Биномиальное распределение моделирует количество успехов в $n$ независимых испытаниях Бернулли с вероятностью успеха $p$ в каждом.

Пример: Для $n=5$ и $p=0.5$, вычисление $P(X=3)$. $P(X=3)=(\genfrac{}{}{0ex}{}{5}{3})(0.5{)}^3(1-0.5{)}^{5-3}=\frac{5!}{3!2!}(0.5{)}^3(0.5{)}^2=10\cdot 0.125\cdot 0.25=0.3125$.

Реализация (используя scipy.stats):

from scipy.stats import binom

n_trials = 5
p_success = 0.5
k_successes = 3

prob_k = binom.pmf(k=k_successes, n=n_trials, p=p_success)
print(f"P(X={k_successes}) for n={n_trials}, p={p_success}: {prob_k}")

9.3. Распределение Пуассона

$$P(X=k)=\frac{{\lambda }^k{e}^{-\lambda }}{k!},k\in \{0,1,2,\dots \}$$ (где $\lambda >0$ - средняя интенсивность (rate) событий)

Объяснение: Распределение Пуассона моделирует количество событий, происходящих в фиксированном интервале времени или пространства, со средней интенсивностью $\lambda$.

Пример: Для $\lambda =3$, вычисление $P(X=2)$. $P(X=2)=\frac{3^2{e}^{-3}}{2!}=\frac{9e^{-3}}{2}\approx \frac{9\times 0.0498}{2}\approx 0.224$.

Реализация (используя scipy.stats):

from scipy.stats import poisson

lambda_rate = 3
k_events = 2

prob_k = poisson.pmf(k=k_events, mu=lambda_rate)
print(f"P(X={k_events}) for lambda={lambda_rate}: {prob_k}")

9.4. Равномерное распределение (непрерывное)

$$f(x)=\frac{1}{b-a},x\in [a,b]$$

Объяснение: Непрерывное равномерное распределение присваивает одинаковую плотность вероятности всем точкам в интервале $[a,b]$.

Пример: Для $a=0,b=2$, $f(1)=\frac{1}{2-0}=\frac{1}{2}$.

Реализация (используя scipy.stats):

from scipy.stats import uniform

a_start = 0
b_end = 2
x_point = 1

# loc = a, scale = b - a
pdf_value = uniform.pdf(x=x_point, loc=a_start, scale=(b_end - a_start))
print(f"PDF at x={x_point} for U({a_start}, {b_end}): {pdf_value}")

9.5. Дискретное равномерное распределение

$$P(X=x)=\frac{1}{n},x\in \{x_1,x_2,\dots ,x_n\}(\text{часто }x\in \{1,2,\dots ,n\})$$

Объяснение: Дискретное равномерное распределение присваивает одинаковую вероятность $n$ дискретным исходам.

Пример: Для $n=6$ (исходы 1, 2, 3, 4, 5, 6), $P(X=3)=\frac{1}{6}$.

Реализация (используя scipy.stats.randint):

from scipy.stats import randint

low_val = 1 # Нижняя граница (включительно)
high_val = 7 # Верхняя граница (не включительно, т.е. исходы 1..6)
n_outcomes = high_val - low_val
k_value = 3

prob_k = randint.pmf(k=k_value, low=low_val, high=high_val)
# Или просто 1.0 / n_outcomes
print(f"P(X={k_value}) for discrete uniform (1 to {n_outcomes}): {prob_k}")

9.6. Нормальное (Гауссово) распределение

$$f(x)=\frac{1}{\sqrt{2\pi {\sigma }^2}}{e}^{-\frac{(x-\mu {)}^2}{2{\sigma }^2}}$$ (где $\mu$ - среднее, ${\sigma }^2$ - дисперсия)

Объяснение: Нормальное распределение моделирует данные с симметричной колоколообразной формой, определяемой средним $\mu$ и стандартным отклонением $\sigma$. Основополагающее распределение в статистике.

Пример: Для $\mu =0,\sigma =1$ (стандартное нормальное), $f(0)=\frac{1}{\sqrt{2\pi }}{e}^0=\frac{1}{\sqrt{2\pi }}\approx 0.3989$.

Реализация (используя scipy.stats):

from scipy.stats import norm

mean_mu = 0
std_dev_sigma = 1
x_point = 0

pdf_value = norm.pdf(x=x_point, loc=mean_mu, scale=std_dev_sigma)
print(f"PDF at x={x_point} for N({mean_mu}, {std_dev_sigma**2}): {pdf_value}")

9.7. Экспоненциальное распределение

$$f(x)=\lambda e^{-\lambda x},x\ge 0$$ (где $\lambda >0$ - параметр интенсивности)

Объяснение: Экспоненциальное распределение моделирует время между событиями в Пуассоновском процессе (процессе с постоянной средней интенсивностью).

Пример: Для $\lambda =2$, $f(1)=2e^{-2\times 1}=2e^{-2}\approx 2\times 0.1353=0.2706$.

Реализация (используя scipy.stats):

from scipy.stats import expon

lambda_rate = 2
# В scipy.stats.expon, scale = 1 / lambda
scale_param = 1 / lambda_rate
x_point = 1

pdf_value = expon.pdf(x=x_point, scale=scale_param)
print(f"PDF at x={x_point} for Exp(lambda={lambda_rate}): {pdf_value}")

9.8. Геометрическое распределение

$$P(X=k)=(1-p{)}^{k-1}p,k\in \{1,2,3,\dots \}$$ (где $p$ - вероятность успеха в одном испытании, $k$ - номер первого успешного испытания)

Объяснение: Геометрическое распределение моделирует количество испытаний Бернулли до первого успеха (включительно).

Пример: Для $p=0.5$, $P(X=3)=(1-0.5{)}^{3-1}(0.5)=(0.5{)}^2(0.5)=0.25\times 0.5=0.125$.

Реализация (используя scipy.stats):

from scipy.stats import geom

p_success = 0.5
k_first_success = 3

prob_k = geom.pmf(k=k_first_success, p=p_success)
print(f"P(X={k_first_success}) for Geom(p={p_success}): {prob_k}")

9.9. Гипергеометрическое распределение

$$P(X=k)=\frac{(\genfrac{}{}{0ex}{}{K}{k})(\genfrac{}{}{0ex}{}{N-K}{n-k})}{(\genfrac{}{}{0ex}{}{N}{n})}$$ (где N - размер совокупности, K - количество успехов в совокупности, n - размер выборки (без возвращения), k - количество успехов в выборке)

Объяснение: Гипергеометрическое распределение моделирует количество успехов в выборке размера $n$, извлеченной без возвращения из конечной совокупности размера N, содержащей K успехов.

Пример: Из N=20 шаров, где K=7 белых, извлекают n=5 шаров. Вероятность извлечь k=3 белых шара.

Реализация (используя scipy.stats):

from scipy.stats import hypergeom

N_population = 20
K_success_population = 7
n_sample = 5
k_success_sample = 3

# M = N (общее число объектов)
# n = K (число объектов типа "успех" в совокупности)
# N = n (размер выборки)
prob_k = hypergeom.pmf(k=k_success_sample, M=N_population, n=K_success_population, N=n_sample)
print(f"P(X={k_success_sample}) for Hypergeom(N={N_population}, K={K_success_population}, n={n_sample}): {prob_k}")

9.10. Бета-распределение

$$f(x;\alpha ,\beta )=\frac{1}{B(\alpha ,\beta )}{x}^{\alpha -1}(1-x{)}^{\beta -1},x\in [0,1]$$ (где $\alpha >0,\beta >0$ - параметры формы, $B(\alpha ,\beta )=\frac{\mathrm{\Gamma }(\alpha )\mathrm{\Gamma }(\beta )}{\mathrm{\Gamma }(\alpha +\beta )}$ - Бета-функция)

Объяснение: Бета-распределение моделирует вероятности (или пропорции), значения которых лежат в интервале [0, 1], как функцию параметров формы $\alpha$ и $\beta$. Часто используется как априорное распределение для параметра Бернулли/биномиального.

Пример: Для $\alpha =2,\beta =3$, вычислить $f(0.5)$.

Реализация (используя scipy.stats):

from scipy.stats import beta

alpha_param = 2
beta_param = 3
x_point = 0.5

pdf_value = beta.pdf(x=x_point, a=alpha_param, b=beta_param)
print(f"PDF at x={x_point} for Beta(alpha={alpha_param}, beta={beta_param}): {pdf_value}")

9.11. Гамма-распределение

$$f(x;\alpha ,\beta )=\frac{{\beta }^{\alpha }}{\mathrm{\Gamma }(\alpha )}{x}^{\alpha -1}{e}^{-\beta x},x>0$$ (где $\alpha >0$ - параметр формы, $\beta >0$ - параметр интенсивности (rate). Иногда параметризуется через масштаб $\theta =1/\beta$)

Объяснение: Гамма-распределение обобщает экспоненциальное распределение (при $\alpha =1$), часто используется для моделирования времени ожидания, сумм случайных величин.

Пример: Для $\alpha =2,\beta =1$, вычислить $f(1)$. $f(1)=\frac{1^2}{\mathrm{\Gamma }(2)}{1}^{2-1}{e}^{-1\times 1}=\frac{1}{1!}1e^{-1}=e^{-1}\approx 0.3679$.

Реализация (используя scipy.stats):

from scipy.stats import gamma

alpha_shape = 2
beta_rate = 1
# В scipy.stats.gamma, 'a' - это форма alpha, 'scale' = 1 / beta_rate
scale_param = 1 / beta_rate
x_point = 1

pdf_value = gamma.pdf(x=x_point, a=alpha_shape, scale=scale_param)
print(f"PDF at x={x_point} for Gamma(alpha={alpha_shape}, beta={beta_rate}): {pdf_value}")

9.12. Мультиномиальное распределение

$$P(X_1=k_1,\dots ,X_c=k_c)=\frac{n!}{k_1!\dots k_c!}{p}_1^{k_1}\dots p_c^{k_c}$$ (где n - количество испытаний, c - количество категорий, $k_i$ - количество исходов i-й категории ($\sum k_i=n$), $p_i$ - вероятность i-й категории ($\sum p_i=1$))

Объяснение: Мультиномиальное распределение обобщает биномиальное распределение на случай с более чем двумя категориями исходов.

Пример: Для n=3 испытаний, c=3 категорий с вероятностями $p=[0.2,0.5,0.3]$, какова вероятность получить по одному исходу каждой категории, т.е., $k=[1,1,1]$. $P=\frac{3!}{1!1!1!}(0.2{)}^1(0.5{)}^1(0.3{)}^1=6\times 0.2\times 0.5\times 0.3=0.18$.

Реализация (используя scipy.stats):

from scipy.stats import multinomial

n_trials = 3
p_probs = [0.2, 0.5, 0.3]
k_counts = [1, 1, 1] # Наблюдаемые количества для каждой категории

prob_k = multinomial.pmf(x=k_counts, n=n_trials, p=p_probs)
print(f"P(k={k_counts}) for Multinomial(n={n_trials}, p={p_probs}): {prob_k}")

9.13. Распределение Хи-квадрат (${\chi }^2$)

$$f(x;k)=\frac{1}{2^{k/2}\mathrm{\Gamma }(k/2)}{x}^{k/2-1}{e}^{-x/2},x>0$$ (где $k$ - число степеней свободы)

Объяснение: Распределение хи-квадрат моделирует сумму квадратов $k$ независимых стандартных нормальных случайных величин. Широко используется в проверке гипотез (например, критерий согласия Пирсона).

Пример: Для $k=3$ степеней свободы, вычислить $f(2)$.

Реализация (используя scipy.stats):

from scipy.stats import chi2

k_df = 3 # Степени свободы
x_point = 2

pdf_value = chi2.pdf(x=x_point, df=k_df)
print(f"PDF at x={x_point} for Chi2(df={k_df}): {pdf_value}")

9.14. Распределение Стьюдента (t-распределение)

$$f(t;\nu )=\frac{\mathrm{\Gamma }((\nu +1)/2)}{\sqrt{\nu \pi }\mathrm{\Gamma }(\nu /2)}{(1+\frac{t^2}{\nu })}^{-(\nu +1)/2}$$ (где $\nu$ - число степеней свободы)

Объяснение: Распределение Стьюдента используется для оценки параметров генеральной совокупности (например, среднего), когда размер выборки мал и дисперсия совокупности неизвестна (оценивается по выборке).

Пример: Для $\nu =5$ степеней свободы, вычислить $f(1)$.

Реализация (используя scipy.stats):

from scipy.stats import t

nu_df = 5 # Степени свободы
t_point = 1

pdf_value = t.pdf(x=t_point, df=nu_df)
print(f"PDF at t={t_point} for Student's t(df={nu_df}): {pdf_value}")

9.15. F-распределение (Фишера-Снедекора)

$$f(x;d_1,d_2)=\frac{1}{B(d_1/2,d_2/2)}{\left(\frac{d_1}{d_2}\right)}^{d_1/2}{x}^{d_1/2-1}{(1+\frac{d_1}{d_2}x)}^{-(d_1+d_2)/2},x>0$$ (где $d_1,d_2$ - степени свободы числителя и знаменателя)

Объяснение: F-распределение моделирует отношение двух независимых хи-квадрат распределенных величин, деленных на их степени свободы. Широко используется в дисперсионном анализе (ANOVA) для сравнения дисперсий.

Пример: Для степеней свободы $d_1=5,d_2=10$, вычислить $f(2)$.

Реализация (используя scipy.stats):

from scipy.stats import f

d1_dfn = 5 # Степени свободы числителя
d2_dfd = 10 # Степени свободы знаменателя
x_point = 2

pdf_value = f.pdf(x=x_point, dfn=d1_dfn, dfd=d2_dfd)
print(f"PDF at x={x_point} for F(dfn={d1_dfn}, dfd={d2_dfd}): {pdf_value}")

9.16. Распределение Лапласа (Двойное экспоненциальное)

$$f(x;\mu ,b)=\frac{1}{2b}{e}^{-\frac{|x-\mu |}{b}}$$ (где $\mu$ - параметр положения (медиана), $b>0$ - параметр масштаба)

Объяснение: Распределение Лапласа, также известное как двойное экспоненциальное, используется для моделирования разностей или ошибок, имеет более тяжелые хвосты, чем нормальное распределение. Связано с L1 регуляризацией.

Реализация (используя scipy.stats):

from scipy.stats import laplace

mu_location = 0
b_scale = 1
x_point = 0

# loc = mu, scale = b
pdf_value = laplace.pdf(x=x_point, loc=mu_location, scale=b_scale)
print(f"PDF at x={x_point} for Laplace(mu={mu_location}, b={b_scale}): {pdf_value}")

9.17. Распределение Рэлея

$$f(x;\sigma )=\frac{x}{{\sigma }^2}{e}^{-x^2/(2{\sigma }^2)},x\ge 0$$ (где $\sigma >0$ - параметр масштаба)

Объяснение: Распределение Рэлея моделирует величину (модуль) двумерного вектора, компоненты которого являются независимыми нормальными случайными величинами с нулевым средним и одинаковой дисперсией ${\sigma }^2$.

Реализация (используя scipy.stats):

from scipy.stats import rayleigh

sigma_scale = 1 # Параметр sigma в формуле
x_point = 2

# В scipy.stats.rayleigh, scale = sigma
pdf_value = rayleigh.pdf(x=x_point, scale=sigma_scale)
print(f"PDF at x={x_point} for Rayleigh(sigma={sigma_scale}): {pdf_value}")

9.18. Треугольное распределение

$$f(x;a,b,c)=\{\begin{array}{ll}\frac{2(x-a)}{(b-a)(c-a)},& a\le x<c\\ \frac{2(b-x)}{(b-a)(b-c)},& c\le x\le b\end{array}$$ (где $a$ - минимум, $b$ - максимум, $c$ - мода ($a\le c\le b$))

Объяснение: Треугольное распределение моделирует данные с известными минимумом, максимумом и модой (наиболее вероятным значением).

Реализация (используя scipy.stats):

from scipy.stats import triang

a_min = 0 # Минимум
b_max = 1 # Максимум
c_mode = 0.5 # Мода

# В scipy.stats.triang:
# loc = a (минимум)
# scale = b - a (диапазон)
# c = (mode - a) / (b - a) (относительное положение моды)
c_relative = (c_mode - a_min) / (b_max - a_min)
x_point = 0.5

pdf_value = triang.pdf(x=x_point, c=c_relative, loc=a_min, scale=(b_max - a_min))
print(f"PDF at x={x_point} for Triangular(a={a_min}, b={b_max}, c={c_mode}): {pdf_value}")

9.19. Логнормальное распределение

$$f(x;\mu ,\sigma )=\frac{1}{x\sigma \sqrt{2\pi }}{e}^{-\frac{(\ln x-\mu {)}^2}{2{\sigma }^2}},x>0$$ (где $\mu ,\sigma$ - среднее и стандартное отклонение логарифма переменной)

Объяснение: Логнормальное распределение моделирует данные, логарифм которых следует нормальному распределению. Часто используется для величин, которые являются произведением многих малых факторов.

Реализация (используя scipy.stats):

from scipy.stats import lognorm

mu_log = 0 # Среднее log(x)
sigma_log = 1 # Стандартное отклонение log(x)
x_point = 2

# В scipy.stats.lognorm:
# s = sigma_log (параметр формы)
# scale = exp(mu_log) (параметр масштаба)
scale_param = np.exp(mu_log)

pdf_value = lognorm.pdf(x=x_point, s=sigma_log, scale=scale_param)
print(f"PDF at x={x_point} for LogNorm(mu_log={mu_log}, sigma_log={sigma_log}): {pdf_value}")

9.20. Арксинусное распределение

$$f(x)=\frac{1}{\pi \sqrt{x(1-x)}},x\in (0,1)$$

Объяснение: Арксинусное распределение (частный случай Бета-распределения с $\alpha =\beta =0.5$) моделирует вероятности, где крайние значения (близкие к 0 и 1) более вероятны, чем значения в середине.

Реализация (используя scipy.stats):

from scipy.stats import arcsine

x_point = 0.5

pdf_value = arcsine.pdf(x=x_point)
print(f"PDF at x={x_point} for Arcsine: {pdf_value}") # 1/(pi*sqrt(0.25)) = 1/(pi*0.5) = 2/pi ~ 0.6366

9.21. Бета-биномиальное распределение

$$P(X=k|n,\alpha ,\beta )=(\genfrac{}{}{0ex}{}{n}{k})\frac{B(k+\alpha ,n-k+\beta )}{B(\alpha ,\beta )}$$ (где $n$ - число испытаний, $\alpha ,\beta$ - параметры Бета-распределения (априорного для p))

Объяснение: Бета-биномиальное распределение моделирует количество успехов в $n$ испытаниях Бернулли, где вероятность успеха $p$ сама является случайной величиной, следующей Бета-распределению. Учитывает избыточную дисперсию по сравнению с биномиальным.

Реализация (используя scipy.stats):

from scipy.stats import betabinom

n_trials = 5
alpha_param = 2
beta_param = 3
k_successes = 2

prob_k = betabinom.pmf(k=k_successes, n=n_trials, a=alpha_param, b=beta_param)
print(f"P(X={k_successes}) for BetaBinom(n={n_trials}, a={alpha_param}, b={beta_param}): {prob_k}")

9.22. Распределение Коши (Лоренца)

$$f(x;x_0,\gamma )=\frac{1}{\pi \gamma [1+{\left(\frac{x-x_0}{\gamma }\right)}^2]}$$ (где $x_0$ - параметр положения (медиана), $\gamma >0$ - параметр масштаба (половина ширины на полувысоте))

Объяснение: Распределение Коши моделирует данные с очень тяжелыми хвостами (среднее и дисперсия не определены). Часто используется в робастной статистике.

Реализация (используя scipy.stats):

from scipy.stats import cauchy

x0_location = 0
gamma_scale = 1
x_point = 0

# loc = x0, scale = gamma
pdf_value = cauchy.pdf(x=x_point, loc=x0_location, scale=gamma_scale)
print(f"PDF at x={x_point} for Cauchy(x0={x0_location}, gamma={gamma_scale}): {pdf_value}") # 1/(pi*1*(1+0)) = 1/pi

9.23. Распределение Вейбулла

$$f(x;k,\lambda )=\frac{k}{\lambda }{\left(\frac{x}{\lambda }\right)}^{k-1}{e}^{-(x/\lambda {)}^k},x\ge 0$$ (где $k>0$ - параметр формы, $\lambda >0$ - параметр масштаба)

Объяснение: Распределение Вейбулла используется в анализе надежности (времени до отказа) и моделировании времени жизни, интенсивности отказов.

Реализация (используя scipy.stats.weibull_min):

from scipy.stats import weibull_min

k_shape = 1.5 # Параметр формы k (в scipy это 'c')
lambda_scale = 1 # Параметр масштаба lambda (в scipy это 'scale')
x_point = 2

# c = k_shape, scale = lambda_scale
pdf_value = weibull_min.pdf(x=x_point, c=k_shape, scale=lambda_scale)
print(f"PDF at x={x_point} for Weibull(k={k_shape}, lambda={lambda_scale}): {pdf_value}")

Примечание: Существует также `weibull_max`. `weibull_min` соответствует приведенной формуле.

9.24. Распределение Парето

$$f(x;x_m,\alpha )=\frac{\alpha x_m^{\alpha }}{x^{\alpha +1}},x\ge x_m$$ (где $x_m>0$ - параметр масштаба (минимальное значение), $\alpha >0$ - параметр формы)

Объяснение: Распределение Парето моделирует распределение богатства, размеров городов и другие явления с тяжелыми хвостами ("принцип 80-20").

Реализация (используя scipy.stats):

from scipy.stats import pareto

alpha_shape = 1 # Параметр формы alpha (в scipy это 'b')
# В scipy, x_m неявно равен 1, если не задан loc/scale.
# Чтобы соответствовать формуле: loc=0, scale=x_m
xm_scale = 1 # Минимальное значение x_m
x_point = 2

# b = alpha_shape, scale = xm_scale
pdf_value = pareto.pdf(x=x_point, b=alpha_shape, scale=xm_scale)
print(f"PDF at x={x_point} for Pareto(alpha={alpha_shape}, xm={xm_scale}): {pdf_value}")

9.25. Лог-Коши распределение

$$f(x;x_0,\gamma )=\frac{1}{x\pi \gamma [1+{\left(\frac{\ln x-\ln x_0}{\gamma }\right)}^2]},x>0$$ (Распределение случайной величины Y, если $\ln Y$ имеет распределение Коши с параметрами $\ln x_0$ и $\gamma$)

Объяснение: Лог-Коши распределение является результатом логарифмического преобразования случайной величины, распределенной по Коши. Имеет тяжелые хвосты.

Реализация (используя scipy.stats.logcauchy):

from scipy.stats import logcauchy

# Параметры соответствующего распределения Коши для log(X)
log_x0_location = 0 # = log(x0)
gamma_scale = 1

x_point = 2 # Значение x > 0

# loc = log_x0_location, scale = gamma_scale
# pdf_value = logcauchy.pdf(x=x_point, loc=log_x0_location, scale=gamma_scale)
# Примечание: logcauchy может отсутствовать в старых версиях SciPy.
# Можно вычислить вручную, используя pdf Коши:
from scipy.stats import cauchy
import numpy as np

if x_point > 0:
    pdf_val_manual = cauchy.pdf(np.log(x_point), loc=log_x0_location, scale=gamma_scale) / x_point
else:
    pdf_val_manual = 0

print(f"PDF at x={x_point} for LogCauchy(log_x0={log_x0_location}, gamma={gamma_scale}): {pdf_val_manual}")

Другие статьи по этой теме:

• 100 Страниц о машинном обучении
• Машинное обучение с помощью Python