Что такое метрика Weighted Mean?

Question

claude-haiku-4.5 · Accepted Answer

## Weighted Mean (взвешенное среднее): использование в ML

Weighted Mean — это обобщение обычного среднего арифметического, где каждому элементу присваивается вес. Это мощный инструмент в Data Science для различных задач.

### Определение

**Взвешенное среднее:**
```
Weighted Mean = Σ(x_i * w_i) / Σ(w_i)

Где:
x_i — i-е значение
w_i — вес для i-го значения
```

**Обычное среднее** это частный случай когда все w_i = 1:
```
Mean = (1*x_1 + 1*x_2 + 1*x_3) / (1 + 1 + 1) = (x_1 + x_2 + x_3) / 3
```

### Практические примеры

#### Пример 1: Средняя оценка студента

```python
import numpy as np

# Оценки и их веса (важность)
grades = np.array([85, 90, 78, 92])  # История, Математика, Физика, Английский
weights = np.array([2, 3, 2, 1])     # Математика важнее всего (3), Английский меньше (1)

# Обычное среднее (все одинаково важны)
simple_mean = grades.mean()
print(f'Простое среднее: {simple_mean:.2f}')
# Output: 86.25 (все веса = 1)

# Взвешенное среднее
weighted_mean = np.average(grades, weights=weights)
print(f'Взвешенное среднее: {weighted_mean:.2f}')
# Output: 87.33 (математика и история имеют больший вес)

# Вручную
weighted_sum = 85*2 + 90*3 + 78*2 + 92*1
total_weight = 2 + 3 + 2 + 1
weighted_mean_manual = weighted_sum / total_weight
print(f'Взвешенное среднее (вручную): {weighted_mean_manual:.2f}')
# Output: 87.33

# Разница видна:
print(f'Разница: {weighted_mean - simple_mean:.2f}')  # 1.08
# Математика (90) имеет вес 3, поэтому среднее смещено вверх
```

#### Пример 2: Portfolio средний return

```python
# Инвестиционный портфель
stocks = ['AAPL', 'GOOGL', 'MSFT', 'TSLA']
returns = np.array([0.15, 0.22, 0.18, 0.35])  # Годовые возвраты
investment = np.array([10000, 5000, 8000, 2000])  # Инвестированная сумма

# Среднее return без весов (плохо)
simple_return = returns.mean()
print(f'Простое среднее return: {simple_return:.2%}')
# Output: 22.50%

# Взвешенное среднее return (правильно)
weighted_return = np.average(returns, weights=investment)
print(f'Взвешенное среднее return: {weighted_return:.2%}')
# Output: 20.07%

# Разница: AAPL имеет наибольший вес (10000), а его return (15%) ниже
# Поэтому взвешенное среднее ниже простого
```

#### Пример 3: Взвешенная точность в классификации

```python
from sklearn.metrics import precision_score, recall_score, f1_score
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier

# Несбалансированный датасет
X, y = make_classification(
    n_samples=1000,
    n_features=10,
    weights=[0.9, 0.1],  # 90% класс 0, 10% класс 1
    random_state=42
)

model = RandomForestClassifier()
model.fit(X, y)
y_pred = model.predict(X)

# Метрики БЕЗ весов (macro)
precision_macro = precision_score(y, y_pred, average='macro')
recall_macro = recall_score(y, y_pred, average='macro')
f1_macro = f1_score(y, y_pred, average='macro')

print('Метрики Macro (без весов):')
print(f'  Precision: {precision_macro:.4f}')
print(f'  Recall: {recall_macro:.4f}')
print(f'  F1: {f1_macro:.4f}')

# Метрики С ВЕСАМИ (weighted)
precision_weighted = precision_score(y, y_pred, average='weighted')
recall_weighted = recall_score(y, y_pred, average='weighted')
f1_weighted = f1_score(y, y_pred, average='weighted')

print('
Метрики Weighted (с весами):')
print(f'  Precision: {precision_weighted:.4f}')
print(f'  Recall: {recall_weighted:.4f}')
print(f'  F1: {f1_weighted:.4f}')

# Разница: Macro среднее одинаково для обоих классов
# Weighted усредняет с учётом количества примеров каждого класса
# Поэтому weighted F1 выше (класс 0 имеет больше примеров)
```

### Weighted Mean в Machine Learning

#### 1. Взвешенная точность (Weighted Accuracy)

```python
# Классификация с несбалансированными классами
from sklearn.metrics import accuracy_score

y_true = np.array([0, 0, 0, 0, 0, 1, 1])  # 5 класс 0, 2 класс 1
y_pred = np.array([0, 0, 0, 1, 0, 1, 0])  # Одна ошибка на каждом классе

# Обычная точность
acc = accuracy_score(y_true, y_pred)
print(f'Обычная точность: {acc:.4f}')  # 5/7 = 0.7143

# Взвешенная точность (вес = количество примеров класса)
weights = np.bincount(y_true)
print(f'Веса классов: {weights}')  # [5, 2]

# Для каждого класса считаем accuracy
acc_class_0 = np.sum((y_true[y_true==0] == y_pred[y_true==0])) / weights[0]
acc_class_1 = np.sum((y_true[y_true==1] == y_pred[y_true==1])) / weights[1]

weighted_acc = (acc_class_0 * weights[0] + acc_class_1 * weights[1]) / sum(weights)
print(f'Взвешенная точность: {weighted_acc:.4f}')  # Обычно то же самое
```

#### 2. Взвешенная средняя квадратичная ошибка (WMSE)

```python
# Когда одни примеры важнее других
y_true = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
y_pred = np.array([1.1, 1.9, 3.2, 3.8, 5.5])
importance = np.array([1, 1, 10, 1, 1])  # Пример 3 очень важен!

# Обычное MSE (все примеры одинаково важны)
mse = np.mean((y_true - y_pred) ** 2)
print(f'Обычное MSE: {mse:.4f}')

# Взвешенное MSE
weighted_mse = np.average((y_true - y_pred) ** 2, weights=importance)
print(f'Взвешенное MSE: {weighted_mse:.4f}')

# Разница видна! Ошибка на примере 3 (0.04) увеличивается в вес 10
# Поэтому weighted MSE выше
```

#### 3. Weighted Average Precision (WAP) в ранжировании

```python
# Рекомендательная система с разными типами товаров
relevance = np.array([1, 1, 0, 1, 0, 1])  # Релевантность товаров
weights = np.array([10, 5, 1, 20, 1, 15])  # Веса товаров (видимость, прибыль)

# Обычная Average Precision
ap = np.sum(relevance) / len(relevance)
print(f'Обычная Average Precision: {ap:.4f}')  # 4/6 = 0.6667

# Weighted Average Precision
wap = np.sum(relevance * weights) / np.sum(weights)
print(f'Weighted Average Precision: {wap:.4f}')

# WAP выше потому что релевантные товары имеют больший вес
```

#### 4. Взвешенное расстояние в кластеризации

```python
import numpy as np
from scipy.spatial.distance import cdist

# Пример: расстояние между двумя точками с разной важностью размеров
point1 = np.array([0, 0, 0])
point2 = np.array([1, 1, 1])

# Размеры: рост, вес, возраст
weights = np.array([1, 10, 1])  # Вес важнее

# Обычное евклидово расстояние
euclidean = np.sqrt(np.sum((point1 - point2) ** 2))
print(f'Обычное расстояние: {euclidean:.4f}')  # sqrt(3) = 1.732

# Взвешенное расстояние
weighted_dist = np.sqrt(np.sum(weights * (point1 - point2) ** 2))
print(f'Взвешенное расстояние: {weighted_dist:.4f}')  # sqrt(12) = 3.464

# Взвешенное расстояние больше потому что различие в весе (второй компонент) больше
```

### Weighted Mean в Pandas

```python
import pandas as pd

# DataFrame с данными
df = pd.DataFrame({
    'Product': ['A', 'B', 'C', 'D'],
    'Price': [100, 150, 200, 250],
    'Quantity': [10, 20, 15, 5]
})

print(df)
#   Product  Price  Quantity
# 0       A    100        10
# 1       B    150        20
# 2       C    200        15
# 3       D    250         5

# Простое среднее цены
avg_price = df['Price'].mean()
print(f'Простое среднее цены: {avg_price:.2f}')  # 175.00

# Взвешенное среднее цены (вес = количество)
weighted_avg_price = (df['Price'] * df['Quantity']).sum() / df['Quantity'].sum()
print(f'Взвешенное среднее цены: {weighted_avg_price:.2f}')  # 156.67

# Или через np.average
weighted_avg_price_2 = np.average(df['Price'], weights=df['Quantity'])
print(f'Взвешенное среднее (np.average): {weighted_avg_price_2:.2f}')  # 156.67

# Разница: товар B имеет меньшую цену (150) но больше количество (20)
# Поэтому взвешенное среднее ниже простого
```

### Weighted Mean в Time Series

```python
# Временные ряды с экспоненциальным взвешиванием
import pandas as pd

data = pd.Series([100, 105, 95, 110, 115])

# Простое скользящее среднее
simple_ma = data.rolling(window=3).mean()
print('Простое скользящее среднее:')
print(simple_ma)

# Экспоненциально взвешенное среднее (недавние значения важнее)
expanded_ma = data.ewm(span=3, adjust=False).mean()
print('
Экспоненциально взвешенное среднее:')
print(expanded_ma)

# EMA даёт больший вес последним значениям
# Полезно для трендов в финансовых данных
```

### Когда использовать Weighted Mean

```python
# ✓ ИСПОЛЬЗУЙ Weighted Mean когда:

# 1. Несбалансированные классы
from sklearn.metrics import f1_score
f1_weighted = f1_score(y_true, y_pred, average='weighted')

# 2. Разная важность примеров
model.fit(X, y, sample_weight=sample_weights)

# 3. Временной ряд (экспоненциальное взвешивание)
df['EMA'] = df['price'].ewm(span=20).mean()

# 4. Портфели и комбинации
portfolio_return = np.average(returns, weights=allocations)

# 5. Оценка качества с несбалансированными данными
from sklearn.metrics import precision_recall_fscore_support
p, r, f, s = precision_recall_fscore_support(y_true, y_pred, average='weighted')

# ✗ НЕ используй Weighted Mean когда:
# - Все примеры одинаково важны
# - Классы сбалансированы
# - Нет причины для весов
```

### Практический пример: ML Pipeline

```python
from sklearn.model_selection import cross_validate
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification

# Несбалансированный датасет
X, y = make_classification(
    n_samples=1000,
    weights=[0.8, 0.2],  # 80% vs 20%
    random_state=42
)

model = RandomForestClassifier()

# Валидация с weighted метриками
scores = cross_validate(
    model, X, y,
    scoring=['precision_weighted', 'recall_weighted', 'f1_weighted'],
    cv=5
)

print(f'Weighted F1: {scores["test_f1_weighted"].mean():.4f}')
print(f'Weighted Precision: {scores["test_precision_weighted"].mean():.4f}')
print(f'Weighted Recall: {scores["test_recall_weighted"].mean():.4f}')

# Weighted метрики учитывают дисбаланс классов
```

### Заключение

**Weighted Mean — это:**
- Обобщение обычного среднего с весами
- Формула: Σ(x_i * w_i) / Σ(w_i)
- Essential для несбалансированных данных
- Используется в классификации, регрессии, ранжировании
- В ML часто используется как метрика качества

**Ключевые применения:**
1. **Несбалансированные классы** → weighted F1-score
2. **Разная важность примеров** → sample_weight
3. **Временные ряды** → EMA (exponentially weighted moving average)
4. **Портфели** → weighted average returns
5. **Разные эксперименты** → weighted average results

**Правило:** когда веса разные → используй weighted mean!

Что такое метрика Weighted Mean?

Комментарии (2)

Weighted Mean (взвешенное среднее): использование в ML

Определение

Практические примеры

Пример 1: Средняя оценка студента

Пример 2: Portfolio средний return

Пример 3: Взвешенная точность в классификации

Weighted Mean в Machine Learning

1. Взвешенная точность (Weighted Accuracy)

2. Взвешенная средняя квадратичная ошибка (WMSE)

3. Weighted Average Precision (WAP) в ранжировании

4. Взвешенное расстояние в кластеризации

Weighted Mean в Pandas

Weighted Mean в Time Series

Когда использовать Weighted Mean

Практический пример: ML Pipeline

Заключение