import matplotlib.pyplot as plt
import numpy as np
import scipy.stats as sps
import seaborn as sns
from matplotlib.patches import Rectangle
from scipy.integrate import quad
from sklearn.neighbors import KernelDensity
from typing import Callable, Union, Optional, Tuple, List

np.random.seed(42)
sns.set_style("darkgrid")
sns.set(font_scale=1.3)

def random_variable_x(omega: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
    """
    Вычисляет значение случайной величины для заданного элементарного исхода.
    Реализует квадратичную зависимость.

    Параметры:
        omega: значение или массив значений элементарного исхода

    Returns:
        Соответствующее значение или массив значений случайной величины
    """
    return omega**2

def conditional_expectation(
    omega_values: np.ndarray,
    partition_size: float = 1.0,
    rv_function: callable = lambda x: x**2
) -> np.ndarray:
    """
    Вычисляет условное математическое ожидание случайной величины
    относительно сигма-алгебры, порожденной разбиением.

    Параметры:
        omega_values: массив значений элементарных исходов
        partition_size: размер интервалов разбиения
        rv_function: функция, задающая случайную величину

    Returns:
        Массив значений условного математического ожидания
    """
    interval_starts = np.floor(omega_values / partition_size) * partition_size
    interval_ends = interval_starts + partition_size

    integrals = np.array([
        quad(rv_function, a, b)[0]
        for a, b in zip(interval_starts, interval_ends)
    ])

    return integrals / partition_size

def plot_conditional_expectations(
    omega: np.ndarray,
    rv_values: np.ndarray,
    cond_exp_values: np.ndarray
) -> None:
    """
    Строит график случайной величины и ее условного математического ожидания.

    Параметры:
        omega: значения элементарных исходов
        rv_values: значения случайной величины
        cond_exp_values: значения условного математического ожидания
    """
    plt.figure(figsize=(8, 6))

    plt.plot(omega, rv_values, label='Случайная величина X(ω)', linewidth=3, color='violet')

    for i in range(10):
        mask = (omega >= i) & (omega < i+1)
        plt.plot(omega[mask], cond_exp_values[mask], linewidth=3, color='orange')

    plt.title('Cлучайная величина и условное математическое ожидание')
    plt.xlabel('Элементарный исход')
    plt.ylabel('Значение')
    plt.legend(['Значение случайной величины', 'Значение условного мат. ожидания'])

    plt.xlim(min(omega) - 0.1, max(omega))
    plt.ylim(min(rv_values) - 1, max(rv_values))

    plt.show()

start = 0.0 # начало отрезка для генерации точек
end = 10.0 # конец отрезка для генерации точек
num_points = 1000 # количество точек для генерации

omega = np.linspace(start, end, num_points) # точки из вероятностного пространства
X_vals = random_variable_x(omega) # значения случайных величин в точках omega
E1_vals = conditional_expectation(omega, 1) # значение УМО

plot_conditional_expectations(omega, X_vals, E1_vals)

E2_vals = conditional_expectation(omega, 2)
plot_conditional_expectations(omega, X_vals, E2_vals)

def generate_cluster_data(n_samples: int = 600) -> Tuple[np.ndarray, np.ndarray]:
    """
    Генерирует три кластера данны.

    Параметры:
    ----------
    n_samples : int
        Общее количество точек данных, которое необходимо сгенерировать.
        Генерируемые точки равномерно распределяются между три кластера:
        - Синусоидальный
        - Линейный
        - Квадратичный

    Возвращаемое значение:
    ----------------------
    Tuple[np.ndarray, np.ndarray]
        Два массива, представляющих координаты X и Y сгенерированных данных соответственно.
    """
    # Синусоидальный кластер
    X_sin = np.random.uniform(-5, 2, n_samples//3)
    Y_sin = 2*np.sin(0.8*X_sin) + np.random.normal(0, 0.3, n_samples//3)

    # Линейный кластер
    X_lin = np.random.uniform(1, 5, n_samples//3)
    Y_lin = 0.7*X_lin - 2 + np.random.normal(0, 0.4, n_samples//3)

    # Квадратичный кластер
    X_quad = np.random.uniform(0, 4, n_samples//3)
    Y_quad = -0.4*(X_quad-2)**2 + 1.5 + np.random.normal(0, 0.3, n_samples//3)

    return np.concatenate([X_sin, X_lin, X_quad]), np.concatenate([Y_sin, Y_lin, Y_quad])

def plot_data(
    X: np.ndarray,
    Y: np.ndarray,
    x_grid: Optional[np.ndarray] = None,
    cond_exp: Optional[np.ndarray] = None,
) -> None:
    """
    Визуализирует сгенерированные данные и, при наличии, условное математическое ожидание.

    Параметры:
    ----------
    X : np.ndarray
        Массив значений для переменной X.

    Y : np.ndarray
        Массив значений для переменной Y, соответствующий X.

    x_grid : Optional[np.ndarray]
        Массив значений вдоль оси X, для которых вычислено условное математическое ожидание.

    cond_exp : Optional[np.ndarray]
        Массив условных математических ожиданий, вычисленных для каждого элемента x_grid.
        Если указано, данные условного математического ожидания будут отображены на графике.
    """
    plt.figure(figsize=(8, 5))

    # Разделение на кластеры
    masks = [
        (X >= -5) & (X <= 2),
        (X >= 1) & (X <= 5),
        (X >= 0) & (X <= 4)
    ]

    for mask in masks:
        plt.scatter(X[mask], Y[mask], c='violet', alpha=0.6)

    # Отрисовка условного ожидания
    if cond_exp is not None and x_grid is not None:
        plt.plot(x_grid, cond_exp, 'k-',
                 lw=3, c='orange', label='Условное математическое ожидание')

    plt.xlabel("Значение X")
    plt.ylabel("Значение Y")
    plt.title("Данные с условным математическим ожиданием")
    plt.show()

X, Y = generate_cluster_data(n_samples=300)
plot_data(X, Y)

def calculate_conditional_expectation(
    X: np.ndarray,
    Y: np.ndarray,
    x_grid: np.ndarray,
    window_size: float = 0.5
) -> np.ndarray:
    """
    Вычисление условного ожидания через усреднение в окрестности
    """
    estimates = []
    for x in x_grid:
        # Находим точки в окрестности x
        in_window = (X >= x - window_size) & (X <= x + window_size)
        estimates.append(np.mean(Y[in_window]) if np.sum(in_window) > 0 else np.nan)
    return np.array(estimates)

x_grid = np.linspace(-5, 5, 1000)
cond_exp = calculate_conditional_expectation(X, Y, x_grid, window_size=0.8)
plot_data(X, Y, x_grid, cond_exp)

<ipython-input-28-85fb880172aa>:71: UserWarning: color is redundantly defined by the 'color' keyword argument and the fmt string "k-" (-> color='k'). The keyword argument will take precedence.
  plt.plot(x_grid, cond_exp, 'k-',

sample_size=1000

X = np.random.choice([1, 2, 3, 4], size=sample_size, p=[0.25, 0.25, 0.25, 0.25])
Y = X + np.random.normal(0, 1, size=sample_size)  # Y = X + ε, где ε ~ N(0,1)

# Определим разбиение пространства исходов
A = (X == 1) | (X == 2)  # Множество A = {1, 2}
B = (X == 3) | (X == 4)  # Множество B = {3, 4}

# Вычислим параметры условных распределений
mu_A, sigma_A = np.mean(Y[A]), np.std(Y[A])
mu_B, sigma_B = np.mean(Y[B]), np.std(Y[B])

# Условное математическое ожидание
conditional_expectation = np.zeros_like(Y, dtype=float)
conditional_expectation[A] = mu_A
conditional_expectation[B] = mu_B

plt.figure(figsize=(10, 6))
plt.scatter(X, Y, alpha=0.5, label='Данные (Y)', c='violet')
plt.hlines(conditional_expectation[A], xmin=0.8, xmax=2.2, linestyles='--',
           color='orange',
           label=f'E(Y|A) = {conditional_expectation[A][0]:.1f}')
plt.hlines(conditional_expectation[B], xmin=2.8, xmax=4.2, linestyles='--',
           color='orange',
           label=f'E(Y|B) = {conditional_expectation[B][0]:.1f}')

plt.xticks([1, 2, 3, 4])
plt.xlabel('X (значения)')
plt.ylabel('Y')
plt.title('Условное математическое ожидание для σ-алгебры F = {∅, A, B, Ω}')
plt.legend()
plt.grid(True)
plt.show()

def mixture_pdf(x: np.ndarray,
               components: List[Tuple[float, float]],
               weights: List[float]) -> np.ndarray:
    """
    Вычисляет плотность вероятности смеси нормальных распределений.

    Parameters
    ----------
    x : np.ndarray
        Массив значений, в которых вычисляется плотность
    components : List[Tuple[float, float]]
        Список параметров компонентов смеси, где каждый элемент -
        кортеж (mean, std) для нормального распределения
    weights : List[float]
        Список весов компонентов (должны суммироваться в 1)

    Returns
    -------
    np.ndarray
        Массив значений плотности вероятности в точках x
    """
    # Нормализация весов
    weights = np.asarray(weights)
    weights = weights / weights.sum()

    # Инициализация массива плотностей
    pdf = np.zeros_like(x)

    # Суммирование компонентов
    for (mu, sigma), w in zip(components, weights):
        pdf += w * sps.norm.pdf(x, mu, sigma)

    return pdf

# Параметры распределений
# Для группы A (X ∈ {1,2})
components_A = [(1, 1), (2, 1)]  # (mean, std) для каждого компонента
weights_A = [0.5, 0.5]  # равные веса

# Для группы B (X ∈ {3,4})
components_B = [(3, 1), (4, 1)]
weights_B = [0.5, 0.5]

# Создаем сетку значений
y_grid = np.linspace(-2, 6, 500)

# Вычисляем плотности
pdf_A = mixture_pdf(y_grid, components_A, weights_A)
pdf_B = mixture_pdf(y_grid, components_B, weights_B)

# Строим график
plt.figure(figsize=(10, 6))
plt.plot(y_grid, pdf_A, linewidth=2, color='violet',
         label=r'Группа A: $\frac{1}{2}\mathcal{N}(1,1) + \frac{1}{2}\mathcal{N}(2,1)$')
plt.plot(y_grid, pdf_B, linewidth=2, color='orange',
         label=r'Группа B: $\frac{1}{2}\mathcal{N}(3,1) + \frac{1}{2}\mathcal{N}(4,1)$')


# Размечаем компоненты смеси пунктиром
for mu, sigma in components_A:
    plt.plot(y_grid, 0.5 * sps.norm.pdf(y_grid, mu, sigma), alpha=0.5,
             color='violet', linestyle='--')
for mu, sigma in components_B:
    plt.plot(y_grid, 0.5 * sps.norm.pdf(y_grid, mu, sigma), alpha=0.5,
             color='orange', linestyle='--')

plt.title('Условные распределения Y как смеси нормальных распределений')
plt.xlabel('значение Y')
plt.ylabel('Плотность вероятности')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

Введение в анализ данных¶

Условное математическое ожидание¶

1. Поведение пользователя на сайте¶

2. Условное математическое ожидание $E(X|\mathscr{F})$ для непрерывной $X$ и дискретной $\mathscr{F}$¶

Разбиение на интервалы длины 1¶

Пример разбиения по интервалам длины 2¶

2. Условное математическое ожидание $\mathsf{E}(Y|X)$ для непрерывных случайных величин¶

3. Условное распределение¶

Пример¶