Agata Rogowska

Regresja izotoniczna

Regresja

Metoda statystyczna, której główną ideą jest przewidywanie pewnej zmiennej na podstawie innych zmiennych.

Formalnie regresja to dowolna metoda statystyczna pozwalająca estymować warunkową wartość oczekiwaną zmiennej losowej, zwanej zmienną objaśnianą, dla zadanych wartości innej zmiennej lub wektora zmiennych losowych (tzw. zmiennych objaśniających).

Wzór na ogólną postać

Ogólny zapis regresji $$y = f(X, \beta) + \epsilon,$$ gdzie:

• $X$ - wektor zmiennych objaśniających
• $y$ - zmienna objaśniana
• $\beta$ - wektor współczynników regresji
• $f(X, \beta)$ - funkcja regresji
• $\epsilon$ - błąd losowy

Regresja, w której występuje więcej niż jedna zmienna objaśniająca, zwana jest regresją wieloraką.

Analiza regresji

Analiza regresji składa się z dwóch części:

• Budowa modelu - wybór funkcji regresji ($f$) opisującej jak zależy nasza wartość oczekiwana ($y$) od cech objaśniających ($X$). Model budujemy tak, by jak najlepiej pasował do danych z próby (zbioru uczącego).
• Stosowanie modelu - zastosowanie zbudowanego modelu do danych w których znamy tylko zmienne objaśniające, w celu wyznaczenia wartości oczekiwanej zmiennej objaśnianej.

W praktyce zawsze występuje pewna wielkość błędu oszacowania. Natomiast im model jest „lepszy” tym ten błąd będzie mniejszy. Ideą regresji jest zminimalizowanie tego błędu oszacowania do tego stopnia, aby model był przydatny w swoich prognozach. Ostatecznie wartościowe będą tylko te modele, dla których błąd oszacowania będzie relatywnie niewielki.

Najpopularniejsze modele parametryczne

• Regresja liniowa
• Uogólnione modele liniowe
• Regresja logistyczna

Istnieją różne typy modeli regresji (algorytmów), które są używane do trenowania modeli uczenia maszynowego, takie jak regresja liniowa, logistyczna, grzbietowa i lasso. Spośród nich model regresji liniowej jest najbardziej podstawowym i najczęściej używanym modelem regresji. Regresja izotoniczna w uczeniu maszynowym opiera się na regresji liniowej.

Regresja nieparametryczna

Alternatywną koncepcją jest regresja nieparametryczna. Metody regresji nieparametrycznej nie zakładają, że estymowana funkcja $f$ jest znana z dokładnością do skończenie wielu estymowalnych parametrów. Tym samym są często bardziej elastyczne w poszukiwaniu rozwiązań. Z drugiej strony w regresji parametrycznej o wiele prostszy jest matematyczny opis modelu.

Regresja izotoniczna

Regresja izotoniczna, inaczej nazywana monotoniczną to algorytm z rodziny regresji, który ma za zadanie dopasować się do obserwacji (najbliżej jak się da), przyjmując formę niemalejącej, ciągłej linii swobodnej.

Słowo "izotoniczny" ma greckie korzenie i składa się z dwóch części: "iso" i "toniczny". Tutaj "iso" oznacza równe, a "toniczny" oznacza rozciąganie. W odniesieniu do algorytmów uczenia maszynowego regresję izotoniczną można zatem rozumieć jako równe rozciąganie wzdłuż linii regresji liniowej.

Funkcja izotoniczna

Niech $x_1 \leq x_2 \leq \ldots \leq x_T$ będzie zbiorem $T$ liniowo uporządkowanych punktów (np. na prostej), oznaczonym przez $X$. Funkcję $f: X \rightarrow R$ nazywamy izotoniczną (niemalejącą) na $X$, gdy $f(x_i) \leq f(x_j)$ dla dowolnych $x_i \leq x_j$.

Regresja izotoniczna

Algorytm

Załóżmy, że dysponujemy zestawem danych $\left\{(x_t, y_t)\right\}_{t=1}^T$.

Problem izotonicznej regresji dotyczy znalezienia funkcji $f$ minimalizującej całkowity błąd kwadratowy na danych, $\sum\limits_{t=1}^T(y_t − f(x_t))^2$. Taka funkcja nazywana jest izotoniczną funkcją regresji.

Regresja izotoniczna poszukuje dopasowania za pomocą metody najmniejszych kwadratów, z dodatkowym warunkiem tj. $\hat{y}_i \leq \hat{y}_j$ zawsze, gdy $x_i \leq x_j$.

Do rozwiązania tego problemu optymalizyjnego używa się algorytmu pool adjacent violators algorithm.

Algorytm pool adjacent violators algorithm

Założenia:

• $Y_i ~ N(\mu_i, \sigma^2)$, gdzie z monotoniczności $x_i \leq x_j \implies \mu_i \leq \mu_j$,
• homoskedastyczność reszt (skończona wariancja).

1. Metoda największej wiarogodności

$-log\left(\prod_{t=1}^Tf(y_t|\mu, \sigma^2)\right) = T\cdot log(\sigma) + \frac{1}{2\sigma^2}\sum_{t=1}^T(y_i - \mu_i)^2$

1. Mnożniki Lagrange'a

$F(x, y, \lambda) = f(x, y) + \lambda G(x, y)$ $L(\mu, \sigma^2, \lambda) = T\cdot log(\sigma) + \frac{1}{2\sigma^2}\sum_{t=1}^T(y_t - \mu_t)^2 + \sum_{t=1}^{T-1}\lambda_t(\mu_t - \mu_{t-1})^2$

1. Warunki Karush-Kuhn-Tucker

Problem nieparametryczny

Mimo prostoty i dużego znaczenia praktycznego, izotoniczna regresja jest przykładem problemu nieparametrycznego, w którym liczba parametrów rośnie liniowo z liczbą danych.

Zastosowanie

Izotoniczna regresja ma fundamentalne znaczenie w statystyce i uczeniu maszynowym, ponieważ ograniczenia izotoniczne występują naturalnie w wielu problemach statystycznych (np. estymacja monotonicznych funkcji gęstości), jak również w wielu zastosowaniach, np. w biologii, medycynie, psychologii.

Regresja izotoniczna ma zastosowanie w wnioskowaniu statystycznym. Na przykład, można jej użyć do dopasowania krzywej izotonicznej do średnich pewnego zestawu wyników eksperymentalnych, gdy spodziewany jest wzrost tych średnich zgodnie z określonym uporządkowaniem. Zaletą regresji izotonicznej jest to, że nie jest ona ograniczona żadną formą funkcjonalną, taką jak liniowość narzucona przez regresję liniową, o ile funkcja jest monotoniczna i rośnie.

Innym zastosowaniem jest niemetryczna skalowanie wielowymiarowe.

Regresja izotoniczna jest również wykorzystywana w klasyfikacji probabilistycznej, aby skalibrować przewidywane prawdopodobieństwa przez nadzorowane modele uczenie maszynowego.

Predykcja

Wynik regresji izotonicznej jest traktowany jako odcinkowo funkcja liniowa. Jeśli dane wejściowe prognozy

• dokładnie pasują do funkcji trenowania, zwracana jest powiązana prognoza;
• są niższe lub wyższe niż wszystkie cechy treningowe, zwracana jest odpowiednio predykcja z najniższą lub najwyższą cechą;
• mieszczą się między dwiema cechami uczącymi, predykcję traktuje się jako odcinkową funkcję liniową, a wartość interpolowaną oblicza się z predykcji dwóch najbliższych cech.

Przykład 1

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection

from sklearn.linear_model import LinearRegression
from sklearn.isotonic import IsotonicRegression
from sklearn.utils import check_random_state

n = 100
x = np.arange(n) # -> [0, ..., 99]
rs = check_random_state(0)
y = 50. * np.log1p(np.arange(n)) + rs.randint(-50, 50, size=(n,)) # y + epsilon

# #############################################################################
# Fit IsotonicRegression and LinearRegression models

ir = IsotonicRegression()

y_ = ir.fit_transform(x, y)

lr = LinearRegression()
lr.fit(x[:, np.newaxis], y)  # x needs to be 2d for LinearRegression

# #############################################################################
# Plot result

segments = [[[i, y[i]], [i, y_[i]]] for i in range(n)]
lc = LineCollection(segments, zorder=0)
lc.set_array(np.ones(len(y)))
lc.set_linewidths(np.full(n, 0.5))

fig = plt.figure()
plt.plot(x, y, 'r.', markersize=12)
plt.plot(x, y_, 'g.-', markersize=12)
plt.plot(x, lr.predict(x[:, np.newaxis]), 'b-')
plt.gca().add_collection(lc)
plt.legend(('Data', 'Isotonic Fit', 'Linear Fit'), loc='lower right')
plt.title('Isotonic regression')
plt.show()

Przykład 2

Do kalibracji prawdopodobieństwa można użyć metody sigmoid co odpowiada metodzie Platta (tj. model regresji logistycznej) lub izotonic, co jest podejściem nieparametrycznym. Nie zaleca się używania kalibracji izotonicznej ze zbyt małą liczbą próbek kalibracyjnych, (<<1000) ponieważ ma ona tendencję do nadmiernego dopasowania.

# evaluate svm with uncalibrated probabilities for imbalanced classification
from numpy import mean
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.svm import SVC
# generate dataset
X, y = make_classification(n_samples=10000, n_features=2, n_redundant=0,
                           n_clusters_per_class=1, weights=[0.99], flip_y=0, random_state=4)

from collections import Counter
Counter(y)

Counter({0: 9900, 1: 100})

Wygenerowaliśmy dane niezbilansowane.

SVM z nieskalibrowanym prawdopodobieństwem na niezbilansowanych danych

# evaluate svm with uncalibrated probabilities for imbalanced classification
from numpy import mean
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.svm import SVC
# generate dataset
X, y = make_classification(n_samples=10000, n_features=2, n_redundant=0,
                           n_clusters_per_class=1, weights=[0.99], flip_y=0, random_state=4)
# define model
model = SVC(gamma='scale')
# define evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(model, X, y, scoring='roc_auc', cv=cv, n_jobs=-1)
# summarize performance
print('Mean ROC AUC: %.3f' % mean(scores))

# define evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(model, X, y, scoring='f1', cv=cv, n_jobs=-1)
# summarize performance
print('Mean F1 score: %.3f' % mean(scores))

Mean ROC AUC: 0.808
Mean F1 score: 0.791

SVM ze skalibrowanym prawdopodobieństwem na niezbilansowanych danych

# evaluate weighted svm with calibrated probabilities for imbalanced classification
from numpy import mean
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.calibration import CalibratedClassifierCV
from sklearn.svm import SVC
# generate dataset
X, y = make_classification(n_samples=10000, n_features=2, n_redundant=0,
                           n_clusters_per_class=1, weights=[0.99], flip_y=0, random_state=4)
# define model
model = SVC(gamma='scale')
# wrap the model
calibrated = CalibratedClassifierCV(model, method='isotonic', cv=3)
# define evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(calibrated, X, y, scoring='roc_auc', cv=cv, n_jobs=-1)
# summarize performance
print('Mean ROC AUC: %.3f' % mean(scores))

# define evaluation procedure
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(calibrated, X, y, scoring='f1', cv=cv, n_jobs=-1)
# summarize performance
print('Mean F1 score: %.3f' % mean(scores))

Mean ROC AUC: 0.867
Mean F1 score: 0.798

Więcej informacji można znaleźć pod wskazanymi linkami

https://machinelearningmastery.com/probability-calibration-for-imbalanced-classification/

https://cat.put.poznan.pl/sites/default/files/Kot%C5%82owski_autoreferat_0.pdf

https://www.analyticsvidhya.com/blog/2021/02/isotonic-regression-and-the-pava-algorithm/

https://www.r-bloggers.com/2020/05/what-is-isotonic-regression/

Agata Rogowska