http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&feedformat=atom&user=DariyakovlevaВикиконспекты - Вклад участника [ru]2026-06-11T20:17:36ZВклад участникаMediaWiki 1.30.0http://neerc.ifmo.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F&diff=69691Логистическая регрессия2019-01-30T20:39:50Z<p>Dariyakovleva: </p>
<hr />
<div><br />
'''Логистическая регрессия''' (англ. ''logistic regression'') — метод построения линейного классификатора, позволяющий оценивать апостериорные вероятности принадлежности объектов классам.<br />
== Описание ==<br />
Логистическая регрессия применяется для прогнозирования вероятности возникновения некоторого события по значениям множества признаков. Для этого вводится зависимая переменная $y$, принимающая значения $0$ и $1$ и множество [[Независимые случайные величины|независимых]] переменных <tex>x_1, ... x_n</tex> на основе значений которых требуется вычислить вероятность принятия того или иного значения зависимой переменной.<br />
<br />
Итак, пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ {{---}} конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex><br />
<br />
Рассмотрим случай двух классов: $Y = \{-1, +1\}$. В логистической регрессии строится линейный алгоритм классификации $a: X \to Y$ вида <br />
<center><tex>a(x, w) = \mathrm{sign}\left(\sum\limits_{j=1}^n w_j f_j(x) - w_0 \right)=\mathrm{sign}\left<x, w\right></tex>,</center><br />
где $w_j$ $-$ вес $j$-го признака, $w_0$ $-$ порог принятия решения, $w=\left(w_0, ..., w_n\right)$ $-$ вектор весов, $\left<x, w\right>$ $-$ скалярное произведение признакового описания объекта на вектор весов. Предполагается, что искусственно введён нулевой признак: $f_{0}(x)=-1$.<br />
<br />
Задача обучения линейного классификатора заключается в том, чтобы по выборке $X^m$ настроить вектор весов $w$. В логистической регрессии для этого решается задача минимизации эмпирического риска с функцией потерь специального вида: <center><tex>Q(w) = \sum\limits_{i=1}^m \ln\left( 1 + \exp( -y_i \langle x_i,w \rangle ) \right) \to \min_{w}</tex>,</center><br />
<br />
После того, как решение $w$ найдено, становится возможным не только вычислять классификацию $a(x) = \mathrm{sign}\langle x,w \rangle$ для произвольного объекта $x$, но и оценивать апостериорные вероятности его принадлежности классам:<br />
<center><tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>,</center><br />
где $\sigma(z) = \frac1{1+e^{-z}}$ {{---}} сигмоидная функция.<br />
<br />
== Обоснование ==<br />
'''С точки зрения [[Байесовский классификатор|байесовского классификатора]]<sup>[на 28.01.19 не создан]</sup>'''<br />
<br />
Наиболее строгое обоснование логистической регрессии опирается на следующую теорему<br />
{{Теорема<br />
|statement=Пусть<br />
*выборка прецедентов $\mathrm{X}^l=\{\left(x_1, y_1\right), ... ,\left(x_l, y_l\right)\}$ получена согласно вероятностному распределению с плотностью <br />
<tex>p\left(x, y\right)=\mathrm{P}_yp_y\left(x\right)=\mathrm{P}\left(y|x\right)p\left(x\right)</tex><br />
где $\mathrm{P}_y$ {{---}} ''априорные вероятности'',<br />
$p_y(x)$ $-$ ''функции правдоподобия'', принадлежащие экспонентному семейству плотностей (т.е. $p_y(x) = \exp \left( \langle\theta,x\rangle \cdot a(\delta) + b(\delta,\theta) + d(x,\delta) \right)$, где $a, b, d$ $-$ произвольные функции);<br />
*функции правдоподобия имеют равные знаения параметра разброса $\delta$ и отличаются только значениями параметра сдвига $\theta_y$;<br />
*среди признаков есть константа, скажем, $f_0(x) = -1$;<br />
Тогда <br />
*линейный классификатор является оптимальным байесовским классификатором;<br />
*апостериорные вероятности классов оценивается по формуле <tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>.<br />
|proof=<br />
<br />
Напомним, что оптимальный байесовский классификатор для двух классов выглядит следущим образом:<br />
<center><tex>a\left(x\right)=<br />
\mathrm{sign}\left(\lambda_+\mathrm{P}\left(+1|x\right)-\lambda_-\mathrm{P}\left(-1|x\right)\right)=<br />
\mathrm{sign}\left(\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)}-\frac{\lambda_-}{\lambda_+}\right)</tex>,</center><br />
<br />
Рассмотрим отношение апостериорных вероятностей классов <br />
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)}</tex>,</center><br />
и распишем функции правдоподобия, используя экспонентную формулу с параметрами $\theta_y$ и $\delta$:<br />
<center><tex>\frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)} = \exp\left(\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle+b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-}\right)</tex>,</center><br />
<br />
Рассмотрим получившуюся под экспонентой сумму: <br />
*$\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle = \langle w, x\rangle$. Вектор $w$ не зависит от $x$ и является вектором свободных коэффициентов(весов) при константных признаках;<br />
*$b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-} = \mathrm{const}\left(x\right)$. Можно считать данные слагаемые аддитивной добавкой к коэффициенту при признаке. Но так как свободные коэффициенты настраиваются по обучающей выборке, вычислять эту добавку не имеет смысла и ее можно включить в $\langle w, x\rangle$.<br />
<br />
Таким образом, <br />
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \mathrm{e}^{\langle w, x\rangle}</tex>,</center><br />
<br />
Разделяющая поверхность в байесовском решающем правиле определяется уравнением <br />
<center><tex>\lambda_- \mathrm{P}\left(-1|x\right) = \lambda_+ \mathrm{P}\left(+1|x\right)</tex>,</center><br />
которое равносильно <br />
<center><tex>\langle w, x\rangle - \ln\frac{\lambda_-}{\lambda_+} = 0</tex>,</center><br />
<br />
Следовательно, разделяющая поверхность линейна и первый пункт теоремы доказан.<br />
<br />
Используя [[Формула полной вероятности|формулу полной вероятности]] получаем следующее равенство<br />
<center><tex>\mathrm{P}\left(+1|x\right) + \mathrm{P}\left(-1|x\right) = \sigma\left(+\langle w ,x\rangle\right) + \sigma\left(-\langle w ,x\rangle\right) = 1</tex>,</center><br />
<br />
Откуда следует:<br />
<center><tex>\mathrm{P}\left(y|x\right)=\sigma\left(\langle w, x\rangle y\right), y = \{-1, +1\}</tex>,</center><br />
Таким образом, второй пункт теоремы доказан.<br />
}}<br />
<br />
== Примеры кода ==<br />
==== scikit-learn ====<br />
Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.'''LogisticRegression'''] имеет несколько параметров, например:<br />
* '''solver''' $-$ алгоритм, использующийся для оптимизации;<br />
* '''multi_class''' $-$ классификация на 2 или много классов.<br />
<br />
<br />
* Импортируем нужные библиотеки:<br />
'''from''' sklearn.linear_model '''import''' LogisticRegression<br />
'''from''' sklearn '''import''' datasets<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
* Выберем тренировочное и тестовое множества:<br />
iris = datasets.'''load_iris()'''<br />
<br />
X = iris.data<br />
y = iris.target<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')<br />
<br />
* Обучение:<br />
clf = LogisticRegression(random_state='''0''', solver='lbfgs', multi_class='multinomial')<br />
model = clf.'''fit'''(X_train, y_train)<br />
<br />
* Предсказание:<br />
y_pred = model.'''predict'''(X_test)<br />
model.'''score'''(X_test, y_test)<br />
<br />
==== [[Примеры кода на Scala#Логистическая регрессия|Пример кода на Scala]] ====<br />
<br />
== См. также ==<br />
* [[Байесовская классификация]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Линейная регрессия]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Вариации регрессии]]<br />
* [[Обзор библиотек для машинного обучения на Python]]<br />
* [[Общие понятия]]<br />
* [[Уменьшение размерности]]<br />
<br />
== Источники информации ==<br />
#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F Логистическая регрессия] $-$ курс лекций Воронцова<br />
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia<br />
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.LogisticRegression] $-$ реализация алгоритма на scikit-learn.org<br />
<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F&diff=69690Логистическая регрессия2019-01-30T20:39:17Z<p>Dariyakovleva: </p>
<hr />
<div><br />
'''Логистическая регрессия''' (англ. ''logistic regression'') — метод построения линейного классификатора, позволяющий оценивать апостериорные вероятности принадлежности объектов классам.<br />
== Описание ==<br />
Логистическая регрессия применяется для прогнозирования вероятности возникновения некоторого события по значениям множества признаков. Для этого вводится зависимая переменная $y$, принимающая значения $0$ и $1$ и множество [[Независимые случайные величины|независимых]] переменных <tex>x_1, ... x_n</tex> на основе значений которых требуется вычислить вероятность принятия того или иного значения зависимой переменной.<br />
<br />
Итак, пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ {{---}} конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex><br />
<br />
Рассмотрим случай двух классов: $Y = \{-1, +1\}$. В логистической регрессии строится линейный алгоритм классификации $a: X \to Y$ вида <br />
<center><tex>a(x, w) = \mathrm{sign}\left(\sum\limits_{j=1}^n w_j f_j(x) - w_0 \right)=\mathrm{sign}\left<x, w\right></tex>,</center><br />
где $w_j$ $-$ вес $j$-го признака, $w_0$ $-$ порог принятия решения, $w=\left(w_0, ..., w_n\right)$ $-$ вектор весов, $\left<x, w\right>$ $-$ скалярное произведение признакового описания объекта на вектор весов. Предполагается, что искусственно введён нулевой признак: $f_{0}(x)=-1$.<br />
<br />
Задача обучения линейного классификатора заключается в том, чтобы по выборке $X^m$ настроить вектор весов $w$. В логистической регрессии для этого решается задача минимизации эмпирического риска с функцией потерь специального вида: <center><tex>Q(w) = \sum\limits_{i=1}^m \ln\left( 1 + \exp( -y_i \langle x_i,w \rangle ) \right) \to \min_{w}</tex>,</center><br />
<br />
После того, как решение $w$ найдено, становится возможным не только вычислять классификацию $a(x) = \mathrm{sign}\langle x,w \rangle$ для произвольного объекта $x$, но и оценивать апостериорные вероятности его принадлежности классам:<br />
<center><tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>,</center><br />
где $\sigma(z) = \frac1{1+e^{-z}}$ {{---}} сигмоидная функция.<br />
<br />
== Обоснование ==<br />
'''С точки зрения [[Байесовский классификатор|байесовского классификатора]]<sup>[на 28.01.19 не создан]</sup>'''<br />
<br />
Наиболее строгое обоснование логистической регрессии опирается на следующую теорему<br />
{{Теорема<br />
|statement=Пусть<br />
*выборка прецедентов $\mathrm{X}^l=\{\left(x_1, y_1\right), ... ,\left(x_l, y_l\right)\}$ получена согласно вероятностному распределению с плотностью <br />
<tex>p\left(x, y\right)=\mathrm{P}_yp_y\left(x\right)=\mathrm{P}\left(y|x\right)p\left(x\right)</tex><br />
где $\mathrm{P}_y$ {{---}} ''априорные вероятности'',<br />
$p_y(x)$ $-$ ''функции правдоподобия'', принадлежащие экспонентному семейству плотностей (т.е. $p_y(x) = \exp \left( \langle\theta,x\rangle \cdot a(\delta) + b(\delta,\theta) + d(x,\delta) \right)$, где $a, b, d$ $-$ произвольные функции);<br />
*функции правдоподобия имеют равные знаения параметра разброса $\delta$ и отличаются только значениями параметра сдвига $\theta_y$;<br />
*среди признаков есть константа, скажем, $f_0(x) = -1$;<br />
Тогда <br />
*линейный классификатор является оптимальным байесовским классификатором;<br />
*апостериорные вероятности классов оценивается по формуле <tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>.<br />
|proof=<br />
<br />
Напомним, что оптимальный байесовский классификатор для двух классов выглядит следущим образом:<br />
<center><tex>a\left(x\right)=<br />
\mathrm{sign}\left(\lambda_+\mathrm{P}\left(+1|x\right)-\lambda_-\mathrm{P}\left(-1|x\right)\right)=<br />
\mathrm{sign}\left(\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)}-\frac{\lambda_-}{\lambda_+}\right)</tex>,</center><br />
<br />
Рассмотрим отношение апостериорных вероятностей классов <br />
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)}</tex>,</center><br />
и распишем функции правдоподобия, используя экспонентную формулу с параметрами $\theta_y$ и $\delta$:<br />
<center><tex>\frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)} = \exp\left(\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle+b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-}\right)</tex>,</center><br />
<br />
Рассмотрим получившуюся под экспонентой сумму: <br />
*$\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle = \langle w, x\rangle$. Вектор $w$ не зависит от $x$ и является вектором свободных коэффициентов(весов) при константных признаках;<br />
*$b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-} = \mathrm{const}\left(x\right)$. Можно считать данные слагаемые аддитивной добавкой к коэффициенту при признаке. Но так как свободные коэффициенты настраиваются по обучающей выборке, вычислять эту добавку не имеет смысла и ее можно включить в $\langle w, x\rangle$.<br />
<br />
Таким образом, <br />
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \mathrm{e}^{\langle w, x\rangle}</tex>,</center><br />
<br />
Разделяющая поверхность в байесовском решающем правиле определяется уравнением <br />
<center><tex>\lambda_- \mathrm{P}\left(-1|x\right) = \lambda_+ \mathrm{P}\left(+1|x\right)</tex>,</center><br />
которое равносильно <br />
<center><tex>\langle w, x\rangle - \ln\frac{\lambda_-}{\lambda_+} = 0</tex>,</center><br />
<br />
Следовательно, разделяющая поверхность линейна и первый пункт теоремы доказан.<br />
<br />
Используя [[Формула полной вероятности|формулу полной вероятности]] получаем следующее равенство<br />
<center><tex>\mathrm{P}\left(+1|x\right) + \mathrm{P}\left(-1|x\right) = \sigma\left(+\langle w ,x\rangle\right) + \sigma\left(-\langle w ,x\rangle\right) = 1</tex>,</center><br />
<br />
Откуда следует:<br />
<center><tex>\mathrm{P}\left(y|x\right)=\sigma\left(\langle w, x\rangle y\right), y = \{-1, +1\}</tex>,</center><br />
Таким образом, второй пункт теоремы доказан.<br />
}}<br />
<br />
== Примеры кода ==<br />
==== scikit-learn ====<br />
Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.'''LogisticRegression'''] имеет несколько параметров, например:<br />
* '''solver''' $-$ алгоритм, использующийся для оптимизации<br />
* '''multi_class''' $-$ классификация на 2 или много классов<br />
<br />
<br />
* Импортируем нужные библиотеки<br />
'''from''' sklearn.linear_model '''import''' LogisticRegression<br />
'''from''' sklearn '''import''' datasets<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
* Выберем тренировочное и тестовое множества<br />
iris = datasets.'''load_iris()'''<br />
<br />
X = iris.data<br />
y = iris.target<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')<br />
<br />
* Обучение<br />
clf = LogisticRegression(random_state='''0''', solver='lbfgs', multi_class='multinomial')<br />
model = clf.'''fit'''(X_train, y_train)<br />
<br />
* Предсказание<br />
y_pred = model.'''predict'''(X_test)<br />
model.'''score'''(X_test, y_test)<br />
<br />
==== [[Примеры кода на Scala#Логистическая регрессия|Пример кода на Scala]] ====<br />
<br />
== См. также ==<br />
* [[Байесовская классификация]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Линейная регрессия]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Вариации регрессии]]<br />
* [[Обзор библиотек для машинного обучения на Python]]<br />
* [[Общие понятия]]<br />
* [[Уменьшение размерности]]<br />
<br />
== Источники информации ==<br />
#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F Логистическая регрессия] $-$ курс лекций Воронцова<br />
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia<br />
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.LogisticRegression] $-$ реализация алгоритма на scikit-learn.org<br />
<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F&diff=69689Логистическая регрессия2019-01-30T20:37:04Z<p>Dariyakovleva: </p>
<hr />
<div><br />
'''Логистическая регрессия''' (англ. ''logistic regression'') — метод построения линейного классификатора, позволяющий оценивать апостериорные вероятности принадлежности объектов классам.<br />
== Описание ==<br />
Логистическая регрессия применяется для прогнозирования вероятности возникновения некоторого события по значениям множества признаков. Для этого вводится зависимая переменная $y$, принимающая значения $0$ и $1$ и множество [[Независимые случайные величины|независимых]] переменных <tex>x_1, ... x_n</tex> на основе значений которых требуется вычислить вероятность принятия того или иного значения зависимой переменной.<br />
<br />
Итак, пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex><br />
<br />
Рассмотрим случай двух классов: $Y = \{-1, +1\}$. В логистической регрессии строится линейный алгоритм классификации $a: X \to Y$ вида <br />
<center><tex>a(x, w) = \mathrm{sign}\left(\sum\limits_{j=1}^n w_j f_j(x) - w_0 \right)=\mathrm{sign}\left<x, w\right></tex></center>,<br />
где $w_j$ $-$ вес $j$-го признака, $w_0$ $-$ порог принятия решения, $w=\left(w_0, ..., w_n\right)$ $-$ вектор весов, $\left<x, w\right>$ $-$ скалярное произведение признакового описания объекта на вектор весов. Предполагается, что искусственно введён нулевой признак: $f_{0}(x)=-1$.<br />
<br />
Задача обучения линейного классификатора заключается в том, чтобы по выборке $X^m$ настроить вектор весов $w$. В логистической регрессии для этого решается задача минимизации эмпирического риска с функцией потерь специального вида: <center><tex>Q(w) = \sum\limits_{i=1}^m \ln\left( 1 + \exp( -y_i \langle x_i,w \rangle ) \right) \to \min_{w}</tex></center>,<br />
<br />
После того, как решение $w$ найдено, становится возможным не только вычислять классификацию $a(x) = \mathrm{sign}\langle x,w \rangle$ для произвольного объекта $x$, но и оценивать апостериорные вероятности его принадлежности классам:<br />
<center><tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex></center>,<br />
где $\sigma(z) = \frac1{1+e^{-z}}$ {{---}} сигмоидная функция.<br />
<br />
== Обоснование ==<br />
'''С точки зрения [[Байесовский классификатор|байесовского классификатора]]<sup>[на 28.01.19 не создан]</sup>'''<br />
<br />
Наиболее строгое обоснование логистической регрессии опирается на следующую теорему<br />
{{Теорема<br />
|statement=Пусть<br />
*выборка прецедентов $\mathrm{X}^l=\{\left(x_1, y_1\right), ... ,\left(x_l, y_l\right)\}$ получена согласно вероятностному распределению с плотностью <br />
<tex>p\left(x, y\right)=\mathrm{P}_yp_y\left(x\right)=\mathrm{P}\left(y|x\right)p\left(x\right)</tex><br />
где $\mathrm{P}_y$ $-$ ''априорные вероятности'',<br />
$p_y(x)$ $-$ ''функции правдоподобия'', принадлежащие экспонентному семейству плотностей (т.е. $p_y(x) = \exp \left( \langle\theta,x\rangle \cdot a(\delta) + b(\delta,\theta) + d(x,\delta) \right)$, где $a, b, d$ $-$ произвольные функции);<br />
*функции правдоподобия имеют равные знаения параметра разброса $\delta$ и отличаются только значениями параметра сдвига $\theta_y$;<br />
*среди признаков есть константа, скажем, $f_0(x) = -1$;<br />
Тогда <br />
*линейный классификатор является оптимальным байесовским классификатором;<br />
*апостериорные вероятности классов оценивается по формуле <tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>.<br />
|proof=<br />
<br />
Напомним, что оптимальный байесовский классификатор для двух классов выглядит следущим образом:<br />
<center><tex>a\left(x\right)=<br />
\mathrm{sign}\left(\lambda_+\mathrm{P}\left(+1|x\right)-\lambda_-\mathrm{P}\left(-1|x\right)\right)=<br />
\mathrm{sign}\left(\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)}-\frac{\lambda_-}{\lambda_+}\right)</tex></center>,<br />
<br />
Рассмотрим отношение апостериорных вероятностей классов <br />
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)}</tex></center><br />
и распишем функции правдоподобия, используя экспонентную формулу с параметрами $\theta_y$ и $\delta$:<br />
<center><tex>\frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)} = \exp\left(\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle+b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-}\right)</tex></center>,<br />
<br />
Рассмотрим получившуюся под экспонентой сумму: <br />
*$\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle = \langle w, x\rangle$. Вектор $w$ не зависит от $x$ и является вектором свободных коэффициентов(весов) при константных признаках;<br />
*$b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-} = \mathrm{const}\left(x\right)$. Можно считать данные слагаемые аддитивной добавкой к коэффициенту при признаке. Но так как свободные коэффициенты настраиваются по обучающей выборке, вычислять эту добавку не имеет смысла и ее можно включить в $\langle w, x\rangle$.<br />
<br />
Таким образом, <br />
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \mathrm{e}^{\langle w, x\rangle}</tex></center>,<br />
<br />
Разделяющая поверхность в байесовском решающем правиле определяется уравнением <br />
<center><tex>\lambda_- \mathrm{P}\left(-1|x\right) = \lambda_+ \mathrm{P}\left(+1|x\right)</tex></center>,<br />
которое равносильно <br />
<center><tex>\langle w, x\rangle - \ln\frac{\lambda_-}{\lambda_+} = 0</tex></center>,<br />
Следовательно, разделяющая поверхность линейна и первый пункт теоремы доказан.<br />
<br />
Используя [[Формула полной вероятности|формулу полной вероятности]] получаем следующее равенство<br />
<center><tex>\mathrm{P}\left(+1|x\right) + \mathrm{P}\left(-1|x\right) = \sigma\left(+\langle w ,x\rangle\right) + \sigma\left(-\langle w ,x\rangle\right) = 1</tex></center>,<br />
<br />
Откуда следует:<br />
<center><tex>\mathrm{P}\left(y|x\right)=\sigma\left(\langle w, x\rangle y\right), y = \{-1, +1\}</tex></center>,<br />
Таким образом, второй пункт теоремы доказан.<br />
}}<br />
<br />
== Примеры кода ==<br />
==== scikit-learn ====<br />
Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.'''LogisticRegression'''] имеет несколько параметров, например:<br />
* '''solver''' $-$ алгоритм, использующийся для оптимизации<br />
* '''multi_class''' $-$ классификация на 2 или много классов<br />
<br />
<br />
* Импортируем нужные библиотеки<br />
'''from''' sklearn.linear_model '''import''' LogisticRegression<br />
'''from''' sklearn '''import''' datasets<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
* Выберем тренировочное и тестовое множества<br />
iris = datasets.'''load_iris()'''<br />
<br />
X = iris.data<br />
y = iris.target<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')<br />
<br />
* Обучение<br />
clf = LogisticRegression(random_state='''0''', solver='lbfgs', multi_class='multinomial')<br />
model = clf.'''fit'''(X_train, y_train)<br />
<br />
* Предсказание<br />
y_pred = model.'''predict'''(X_test)<br />
model.'''score'''(X_test, y_test)<br />
<br />
==== [[Примеры кода на Scala#Логистическая регрессия|Пример кода на Scala]] ====<br />
<br />
== См. также ==<br />
* [[Байесовская классификация]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Линейная регрессия]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Вариации регрессии]]<br />
* [[Обзор библиотек для машинного обучения на Python]]<br />
* [[Общие понятия]]<br />
* [[Уменьшение размерности]]<br />
<br />
== Источники информации ==<br />
#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F Логистическая регрессия] $-$ курс лекций Воронцова<br />
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia<br />
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.LogisticRegression] $-$ реализация алгоритма на scikit-learn.org<br />
<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D1%82%D0%BE%D1%85%D0%B0%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA&diff=69688Стохастический градиентный спуск2019-01-30T20:35:18Z<p>Dariyakovleva: </p>
<hr />
<div>'''Стохастический градиентный спуск''' (англ. ''stochastic gradient descent'') $-$ оптимизационный алгоритм, отличающийся от обычного [https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA градиентного спуска] тем, что градиент оптимизируемой функции считается на каждом шаге не как сумма градиентов от каждого элемента выборки, а как градиент от одного, случайно выбранного элемента.<br />
<br />
== Обычный градиентный спуск ==<br />
Для начала вспомним, как работает обычный градиентный спуск. Пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>\{(x_1,y_1),\dots,(x_l,y_l)\}.</tex> Пусть семейство алгоритмов $a(x, {\bf w})$ имеет параметр вектор весов $\bf w$. И пускай мы выбрали какую-нибудь функцию потерь. Для $i$-го объекта выборки для алгоритма с весами ${\bf w}$ обозначим ее <tex> \mathscr{L}_i({\bf w}) </tex>. Необходимо минимизировать эмпирический риск, т.е. <tex>Q(w) = \sum\limits_{i=1}^l \mathscr{L}_i(w) \,\to\, \min\limits_{\bf w}</tex>. Если функция потерь принадлежит классу $C_1(X)$, то можно применить метод градиентного спуска. Выберем ${\bf w}^{(0)}$ $-$ начальное приближение. Тогда каждый следующий вектор параметров будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\sum\limits_{i=1}^{l}\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $h$ - градиентный шаг, смысл которого заключается в том, насколько сильно менять вектор весов в направлении градиента. Остановка алгоритма будет определяться сходимостью $Q$ или $\bf w$.<br />
<br />
== Стохастический градиентный спуск ==<br />
Проблема предыдущего алгоритма заключается в том, что чтобы определить новое приближение вектора весов необходимо вычислить градиент от каждого элемента выборки, что может сильно замедлять алгоритм. Идея ускорения алгоритма заключается в использовании только одного элемента, либо некоторой подвыборки для подсчета нового приближения весов. То есть теперь новое приближение будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} $-$ h\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $i$ $-$ случайно выбранный индекс. Так как теперь направление изменения $\bf w$ будет определяться за $O(1)$, подсчет $Q$ на каждом шаге будет слишком дорогостоящим. Для того, чтобы ускорить оценку $Q$, будем использовать приближенную рекуррентную формулу. Можно выбрать одну из следующих формул:<br />
* среднее арифметическое: $\overline{Q}_m = \dfrac{1}{m}\varepsilon_m + \dfrac{1}{m}\varepsilon_{m - 1} + \dfrac{1}{m}\varepsilon_{m - 2} + \dots = \dfrac{1}{m}\varepsilon_m + (1 - \dfrac{1}{m})\overline{Q}_{m-1}$;<br />
* экспоненциальное скользящее среднее: $\overline{Q}_m = \lambda\varepsilon_m + (1 - \lambda)\varepsilon_{m - 1} + (1 - \lambda)^2\varepsilon_{m - 2} + \dots = \lambda\varepsilon_m + (1-\lambda)\overline{Q}_{m - 1},$ где $\lambda$ $-$ темп забывания предыстории ряда.<br />
<br />
== Псевдокод ==<br />
'''def''' SGD(X, h, $\lambda$)''':''' <font color=green> # где X $-$ выборка, h $-$ градиентный шаг, а $\lambda$ $-$ темп забывания </font><br />
${\bf w} =$ initialize_weights() <font color=green> # инициализировать веса </font><br />
$\overline{Q} = \frac{1}{l} \sum_{i=1}^{l}\mathscr{L}_i({\bf w})$ <font color=green># инициализировать оценку функционала </font><br />
'''while''' $Q$ not converges '''or''' ${\bf w}$ not converges''':'''<br />
$i =$ rand() % $l$ <font color=green> # случайно выбрать элемент, по которому будет считаться градиент </font><br />
$\varepsilon = \mathscr{L}_i({\bf w})$ <font color=green> # вычислить потерю </font><br />
${\bf w} = {\bf w} - h \nabla \mathscr{L}_i({\bf w})$ <font color=green># обновить вектор весов в направлении градиента</font><br />
$\overline{Q} = \lambda\varepsilon + (1 - \lambda)\overline{Q}$ <font color=green># оценить функционал</font><br />
'''return''' w<br />
<br />
== Эвристики ==<br />
Существует несколько способов инициализировать веса:<br />
* ${\bf w} = {\bf 0}$;<br />
* $w_j = random(-\dfrac{1}{2n}, \dfrac{1}{2n})$. Стоит брать небольшие случайные веса, так как если выбрать их слишком большими, в некоторых случаях (к примеру в случае нейрона с [[Нейронные_сети,_перцептрон|функцией активациии]] равной арктангенсу) большие начальные значения веса могут привести в область с малыми по модулю производными, в связи с чем из такой области будет трудно выбраться;<br />
* $w_j = \dfrac{\langle y, f_j \rangle}{\langle f_j, f_j \rangle}$, где $f_j = (f_j(x_i))_{i=1}^l$. Оценка оптимальная в случае, если функция потерь квадратична и признаки нескоррелированы, то есть $\langle f_j, f_k \rangle = 0, j \neq k$.<br />
Так же можно запустить спуск несколько раз с разными начальными приближениями и выбрать лучшее решение.<br />
<br />
<br />
При выборе случайного элемента можно использовать следующие эвристики:<br />
* брать объекты из разных классов;<br />
* брать объекты, на которых ошибка больше, то есть чем меньше отступ (в метрических классификаторах расстояние от разделяющей поверхности до объекта) i-го объекта $M_i$, тем больше вероятность взять этот объект;<br />
* брать объекты, на которых уверенность меньше, то есть чем меньше $|M_i|$, тем больше вероятность взять этот объект;<br />
* не брать объекты, на которых уже высокая уверенность ($M_i > \mu_+$) либо не брать объекты-выбросы ($M_i<\mu_i$);<br />
<br />
Выбирать величину градиентного шага можно следующими способами:<br />
* $h_t = \dfrac{1}{t}$;<br />
* метод скорейшего градиентного спуска: $\mathscr{L}_i({\bf w} - h\nabla \mathscr{L}_i({\bf w})) \rightarrow \min\limits_h$;<br />
* при квадратичной функции потерь можно использовать $h = ||x_i||^2$;<br />
* иногда можно выполнять пробные шаги, а именно увеличивать $h$ для выбивания процесса из локальных минимумов;<br />
* [https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D0%B1%D0%B5%D1%80%D0%B3%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%80%D0%BA%D0%B2%D0%B0%D1%80%D0%B4%D1%82%D0%B0 метод Левенберга-Марквардта];<br />
<br />
== Регуляризация ==<br />
Основным способом уменьшить переобучение является [[Регулярищация|регуляризация]]<sup>[на 28.01.19 не создан]</sup>, т.е. сокращение весов. Будем штрафовать за увеличение нормы вектора весов, для этого перепишем функцию потерь $\tilde{\mathscr{L}}_i({\bf w}) = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2}||w||^2 = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2} \sum\limits_{j=1}^nw_j^2 \rightarrow \min\limits_w$, где $\tau$ $-$ коэффициент регуляризации.<br />
<br />
Тогда градиент будет следующим: $\nabla \tilde{\mathscr{L}}_i({\bf w}) = \nabla \mathscr{L}_i({\bf w}) + \tau {\bf w}$, а градиентный шаг будет выглядеть так: ${\bf w} = {\bf w}(1 - h\tau) - h\nabla \mathscr{L}_i({\bf w})$.<br />
<br />
== Достоинства и недостатки ==<br />
'''Достониства:'''<br />
* легко реализуется;<br />
* функция потерь и семейство алгоритмов могут быть любыми (если функция потерь не дифференцируема, ее можно аппроксимировать дифференцируемой);<br />
* легко добавить регуляризацию;<br />
* возможно потоковое обучение;<br />
* подходит для задач с большими данными, иногда можно получить решение даже не обработав всю выборку;<br />
'''Недостатки'''<br />
* нет универсального набора эвристик, их нужно выбирать для конкретной задачи отдельно;<br />
<br />
<br />
== Пример кода scikit-learn == <br />
Классификатор [https://scikit-learn.org/stable/modules/sgd.html sklearn.linear_model.'''SGDClassifier'''] имеет несколько параметров, например: <br />
<br />
'''loss''' $-$ функция потерь. По умолчанию используется "hinge", дающая алгоритм линейного SVM;<br />
<br />
'''penalty''' $-$ метод регуляризации. По умолчанию "l2";<br />
<br />
'''alpha''' $-$ $\tau$, коэффициент регуляризации;<br />
<br />
'''learning_rate''' $-$ алгоритм изменения градиентного шага;<br />
<br />
'''eta0''' $-$ начальный градиентный шаг;<br />
<br />
'''shuffle''' перемешивать тренировочную выборку после каждой итерации;<br />
<br />
* Импортируем нужные библиотеки:<br />
'''from''' sklearn.linear_model '''import''' SGDClassifier<br />
'''from''' sklearn '''import''' datasets<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
* Выберем тренировочное и тестовое множества:<br />
iris = datasets.'''load_iris()'''<br />
<br />
X = iris.data<br />
y = iris.target<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')<br />
<br />
* Обучение:<br />
clf = SGDClassifier(shuffle = True)<br />
model = clf.'''fit'''(X_train, y_train)<br />
<br />
* Предсказание:<br />
y_pred = model.'''predict'''(X_test)<br />
model.'''score'''(X_test, y_test)<br />
<br />
== См. также ==<br />
* [[Общие понятия]]<br />
* [[Обзор библиотек для машинного обучения на Python]]<br />
<br />
== Источники информации ==<br />
#[http://www.machinelearning.ru/wiki/images/5/53/Voron-ML-Lin-SG.pdf Метод стохастического градиента] $-$ презентация Воронцова<br />
#[https://www.youtube.com/watch?v=4BKQ3GZR32w&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=4 Метод стохастического градиента] $-$ запись лекции Воронцова<br />
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia<br />
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html#sklearn.linear_model.SGDClassifier.decision_function sklearn.linear_model.SGDClassifier] $-$ описание алгоритма на scikit-learn.org<br />
<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D1%82%D0%BE%D1%85%D0%B0%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA&diff=69687Стохастический градиентный спуск2019-01-30T20:34:58Z<p>Dariyakovleva: </p>
<hr />
<div>'''Стохастический градиентный спуск''' (англ. ''stochastic gradient descent'') $-$ оптимизационный алгоритм, отличающийся от обычного [https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA градиентного спуска] тем, что градиент оптимизируемой функции считается на каждом шаге не как сумма градиентов от каждого элемента выборки, а как градиент от одного, случайно выбранного элемента.<br />
<br />
== Обычный градиентный спуск ==<br />
Для начала вспомним, как работает обычный градиентный спуск. Пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>\{(x_1,y_1),\dots,(x_l,y_l)\}.</tex> Пусть семейство алгоритмов $a(x, {\bf w})$ имеет параметр вектор весов $\bf w$. И пускай мы выбрали какую-нибудь функцию потерь. Для $i$-го объекта выборки для алгоритма с весами ${\bf w}$ обозначим ее <tex> \mathscr{L}_i({\bf w}) </tex>. Необходимо минимизировать эмпирический риск, т.е. <tex>Q(w) = \sum\limits_{i=1}^l \mathscr{L}_i(w) \,\to\, \min\limits_{\bf w}</tex>. Если функция потерь принадлежит классу $C_1(X)$, то можно применить метод градиентного спуска. Выберем ${\bf w}^{(0)}$ $-$ начальное приближение. Тогда каждый следующий вектор параметров будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\sum\limits_{i=1}^{l}\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $h$ - градиентный шаг, смысл которого заключается в том, насколько сильно менять вектор весов в направлении градиента. Остановка алгоритма будет определяться сходимостью $Q$ или $\bf w$.<br />
<br />
== Стохастический градиентный спуск ==<br />
Проблема предыдущего алгоритма заключается в том, что чтобы определить новое приближение вектора весов необходимо вычислить градиент от каждого элемента выборки, что может сильно замедлять алгоритм. Идея ускорения алгоритма заключается в использовании только одного элемента, либо некоторой подвыборки для подсчета нового приближения весов. То есть теперь новое приближение будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} $-$ h\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $i$ $-$ случайно выбранный индекс. Так как теперь направление изменения $\bf w$ будет определяться за $O(1)$, подсчет $Q$ на каждом шаге будет слишком дорогостоящим. Для того, чтобы ускорить оценку $Q$, будем использовать приближенную рекуррентную формулу. Можно выбрать одну из следующих формул:<br />
* среднее арифметическое: $\overline{Q}_m = \dfrac{1}{m}\varepsilon_m + \dfrac{1}{m}\varepsilon_{m - 1} + \dfrac{1}{m}\varepsilon_{m - 2} + \dots = \dfrac{1}{m}\varepsilon_m + (1 - \dfrac{1}{m})\overline{Q}_{m-1}$<br />
* экспоненциальное скользящее среднее: $\overline{Q}_m = \lambda\varepsilon_m + (1 - \lambda)\varepsilon_{m - 1} + (1 - \lambda)^2\varepsilon_{m - 2} + \dots = \lambda\varepsilon_m + (1-\lambda)\overline{Q}_{m - 1},$ где $\lambda$ $-$ темп забывания предыстории ряда.<br />
<br />
== Псевдокод ==<br />
'''def''' SGD(X, h, $\lambda$)''':''' <font color=green> # где X $-$ выборка, h $-$ градиентный шаг, а $\lambda$ $-$ темп забывания </font><br />
${\bf w} =$ initialize_weights() <font color=green> # инициализировать веса </font><br />
$\overline{Q} = \frac{1}{l} \sum_{i=1}^{l}\mathscr{L}_i({\bf w})$ <font color=green># инициализировать оценку функционала </font><br />
'''while''' $Q$ not converges '''or''' ${\bf w}$ not converges''':'''<br />
$i =$ rand() % $l$ <font color=green> # случайно выбрать элемент, по которому будет считаться градиент </font><br />
$\varepsilon = \mathscr{L}_i({\bf w})$ <font color=green> # вычислить потерю </font><br />
${\bf w} = {\bf w} - h \nabla \mathscr{L}_i({\bf w})$ <font color=green># обновить вектор весов в направлении градиента</font><br />
$\overline{Q} = \lambda\varepsilon + (1 - \lambda)\overline{Q}$ <font color=green># оценить функционал</font><br />
'''return''' w<br />
<br />
== Эвристики ==<br />
Существует несколько способов инициализировать веса:<br />
* ${\bf w} = {\bf 0}$;<br />
* $w_j = random(-\dfrac{1}{2n}, \dfrac{1}{2n})$. Стоит брать небольшие случайные веса, так как если выбрать их слишком большими, в некоторых случаях (к примеру в случае нейрона с [[Нейронные_сети,_перцептрон|функцией активациии]] равной арктангенсу) большие начальные значения веса могут привести в область с малыми по модулю производными, в связи с чем из такой области будет трудно выбраться;<br />
* $w_j = \dfrac{\langle y, f_j \rangle}{\langle f_j, f_j \rangle}$, где $f_j = (f_j(x_i))_{i=1}^l$. Оценка оптимальная в случае, если функция потерь квадратична и признаки нескоррелированы, то есть $\langle f_j, f_k \rangle = 0, j \neq k$.<br />
Так же можно запустить спуск несколько раз с разными начальными приближениями и выбрать лучшее решение.<br />
<br />
<br />
При выборе случайного элемента можно использовать следующие эвристики:<br />
* брать объекты из разных классов;<br />
* брать объекты, на которых ошибка больше, то есть чем меньше отступ (в метрических классификаторах расстояние от разделяющей поверхности до объекта) i-го объекта $M_i$, тем больше вероятность взять этот объект;<br />
* брать объекты, на которых уверенность меньше, то есть чем меньше $|M_i|$, тем больше вероятность взять этот объект;<br />
* не брать объекты, на которых уже высокая уверенность ($M_i > \mu_+$) либо не брать объекты-выбросы ($M_i<\mu_i$);<br />
<br />
Выбирать величину градиентного шага можно следующими способами:<br />
* $h_t = \dfrac{1}{t}$;<br />
* метод скорейшего градиентного спуска: $\mathscr{L}_i({\bf w} - h\nabla \mathscr{L}_i({\bf w})) \rightarrow \min\limits_h$;<br />
* при квадратичной функции потерь можно использовать $h = ||x_i||^2$;<br />
* иногда можно выполнять пробные шаги, а именно увеличивать $h$ для выбивания процесса из локальных минимумов;<br />
* [https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D0%B1%D0%B5%D1%80%D0%B3%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%80%D0%BA%D0%B2%D0%B0%D1%80%D0%B4%D1%82%D0%B0 метод Левенберга-Марквардта];<br />
<br />
== Регуляризация ==<br />
Основным способом уменьшить переобучение является [[Регулярищация|регуляризация]]<sup>[на 28.01.19 не создан]</sup>, т.е. сокращение весов. Будем штрафовать за увеличение нормы вектора весов, для этого перепишем функцию потерь $\tilde{\mathscr{L}}_i({\bf w}) = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2}||w||^2 = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2} \sum\limits_{j=1}^nw_j^2 \rightarrow \min\limits_w$, где $\tau$ $-$ коэффициент регуляризации.<br />
<br />
Тогда градиент будет следующим: $\nabla \tilde{\mathscr{L}}_i({\bf w}) = \nabla \mathscr{L}_i({\bf w}) + \tau {\bf w}$, а градиентный шаг будет выглядеть так: ${\bf w} = {\bf w}(1 - h\tau) - h\nabla \mathscr{L}_i({\bf w})$.<br />
<br />
== Достоинства и недостатки ==<br />
'''Достониства:'''<br />
* легко реализуется;<br />
* функция потерь и семейство алгоритмов могут быть любыми (если функция потерь не дифференцируема, ее можно аппроксимировать дифференцируемой);<br />
* легко добавить регуляризацию;<br />
* возможно потоковое обучение;<br />
* подходит для задач с большими данными, иногда можно получить решение даже не обработав всю выборку;<br />
'''Недостатки'''<br />
* нет универсального набора эвристик, их нужно выбирать для конкретной задачи отдельно;<br />
<br />
<br />
== Пример кода scikit-learn == <br />
Классификатор [https://scikit-learn.org/stable/modules/sgd.html sklearn.linear_model.'''SGDClassifier'''] имеет несколько параметров, например: <br />
<br />
'''loss''' $-$ функция потерь. По умолчанию используется "hinge", дающая алгоритм линейного SVM;<br />
<br />
'''penalty''' $-$ метод регуляризации. По умолчанию "l2";<br />
<br />
'''alpha''' $-$ $\tau$, коэффициент регуляризации;<br />
<br />
'''learning_rate''' $-$ алгоритм изменения градиентного шага;<br />
<br />
'''eta0''' $-$ начальный градиентный шаг;<br />
<br />
'''shuffle''' перемешивать тренировочную выборку после каждой итерации;<br />
<br />
* Импортируем нужные библиотеки:<br />
'''from''' sklearn.linear_model '''import''' SGDClassifier<br />
'''from''' sklearn '''import''' datasets<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
* Выберем тренировочное и тестовое множества:<br />
iris = datasets.'''load_iris()'''<br />
<br />
X = iris.data<br />
y = iris.target<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')<br />
<br />
* Обучение:<br />
clf = SGDClassifier(shuffle = True)<br />
model = clf.'''fit'''(X_train, y_train)<br />
<br />
* Предсказание:<br />
y_pred = model.'''predict'''(X_test)<br />
model.'''score'''(X_test, y_test)<br />
<br />
== См. также ==<br />
* [[Общие понятия]]<br />
* [[Обзор библиотек для машинного обучения на Python]]<br />
<br />
== Источники информации ==<br />
#[http://www.machinelearning.ru/wiki/images/5/53/Voron-ML-Lin-SG.pdf Метод стохастического градиента] $-$ презентация Воронцова<br />
#[https://www.youtube.com/watch?v=4BKQ3GZR32w&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=4 Метод стохастического градиента] $-$ запись лекции Воронцова<br />
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia<br />
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html#sklearn.linear_model.SGDClassifier.decision_function sklearn.linear_model.SGDClassifier] $-$ описание алгоритма на scikit-learn.org<br />
<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9D%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8,_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD&diff=69686Нейронные сети, перцептрон2019-01-30T20:33:51Z<p>Dariyakovleva: </p>
<hr />
<div>'''Искусственная нейронная сеть (ИНС)''' (англ. ''Artificial neural network (ANN)'') {{---}} упрощенная модель биологической нейронной сети, представляющая собой совокупность искусственных нейронов, взаимодействующих между собой.<br />
<br />
[[File:Нейронная_сеть.png|700px|thumb|[https://neuralnet.info/chapter/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5/#%D0%92-%D1%86%D0%B5%D0%BB%D0%BE%D0%BC-%D0%BE%D0%B1-%D0%98%D0%9D%D0%A1 Упрощение биологической нейронной сети]]]<br />
<br />
Основные принципы работы нейронных сетей были описаны еще в 1943 году Уорреном Мак-Каллоком и Уолтером Питтсом<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref>. В 1957 году нейрофизиолог Фрэнк Розенблатт разработал первую нейронную сеть<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref>, а в 2010 году большие объемы данных для обучения открыли возможность использовать нейронные сети для машинного обучения.<br />
<br />
На данный момент нейронные сети используются в многочисленных областях машинного обучения и решают проблемы различной сложности.<br />
<br />
==Структура нейронной сети==<br />
<br />
[[File:Искусственный_нейрон_схема.png|700px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD Схема искусственного нейрона]]]<br />
<br />
Хорошим примером биологической нейронной сети является человеческий мозг. Наш мозг {{---}} сложнейшая биологическая нейронная сеть, которая принимает информацию от органов чувств и каким-то образом ее обрабатывает (узнавание лиц, возникновение ощущений и т.д.). Мозг же, в свою очередь, состоит из нейронов, взаимодействующих между собой.<br />
<br />
Для построения искусственной нейронной сети будем использовать ту же структуру. Как и биологическая нейронная сеть, искусственная состоит из нейронов, взаимодействующих между собой, однако представляет собой упрощенную модель. Так, например, искусственный нейрон, из которых состоит ИНС, имеет намного более простую структуру: у него есть несколько входов, на которых он принимает различные сигналы, преобразует их и передает другим нейронам. Другими словами, искусственный нейрон {{---}} это такая функция <tex>\mathbb{R}^n \rightarrow \mathbb{R}</tex>, которая преобразует несколько входных параметров в один выходной.<br />
<br />
Как видно на рисунке справа, у нейрона есть <tex>n</tex> входов <tex>x_i</tex>, у каждого из которого есть вес <tex>w_i</tex>, на который умножается сигнал, проходящий по связи. После этого взвешенные сигналы <tex>x_i \cdot w_i</tex> направляются в сумматор, который аггрегирует все сигналы во взвешенную сумму. Эту сумму также называют <tex>net</tex>. Таким образом, <tex>net = \sum_{i=1}^{i=n} w_i \cdot x_i = w^T \cdot x</tex>.<br />
<br />
Просто так передавать взвешенную сумму <tex>net</tex> на выход достаточно бессмысленно {{---}} нейрон должен ее как-то обработать и сформировать адекватный выходной сигнал. Для этих целей используют [[Практики реализации нейронных сетей#Функции активации|функцию активации]], которая преобразует взвешенную сумму в какое-то число, которое и будет являться выходом нейрона. Функция активации обозначается <tex>\phi(net)</tex>. Таким образом, выходов искусственного нейрона является <tex>\phi(net)</tex>.<br />
<br />
Для разных типов нейронов используют самые разные функции активации, но одними из самых популярных являются:<br />
* Функция единичного скачка. Если <tex>net > threshold</tex>, <tex>\phi(net) = 1</tex>, а иначе <tex>0</tex>;<br />
* Сигмоидальная функция. <tex>\phi(net) = \frac{1}{1 + exp(-a \cdot net)}</tex>, где параметр <tex>a</tex> характеризует степень крутизны функции;<br />
* Гиперболический тангенс. <tex>\phi(net) = tanh(\frac{net}{a})</tex>, где параметр <tex>a</tex> также определяет степень крутизны графика функции;<br />
* Rectified linear units (ReLU). <tex>ReLU(x) = \begin{cases}<br />
x & x \geq 0 \\<br />
0 & x < 0<br />
\end{cases} = \max(x, 0)</tex>.<br />
<br />
==Виды нейронных сетей==<br />
<br />
Разобравшись с тем, как устроен нейрон в нейронной сети, осталось понять, как их в этой сети располагать и соединять.<br />
<br />
Как правило, в большинстве нейронных сетей есть так называемый ''входной слой'', который выполняет только одну задачу {{---}} распределение входных сигналов остальным нейронам. Нейроны этого слоя не производят никаких вычислений. В остальном нейронные сети делятся на основные категории, представленные ниже.<br />
<br />
===Однослойные нейронные сети===<br />
<br />
[[File:Single-layer-neural-net-scheme.png|500px|thumb|[https://studfiles.net/preview/3170620/page:3/ Схема однослойной нейронной сети]]]<br />
<br />
'''Однослойная нейронная сеть''' (англ. ''Single-layer neural network'') {{---}} сеть, в которой сигналы от входного слоя сразу подаются на выходной слой, который и преобразует сигнал и сразу же выдает ответ.<br />
<br />
Как видно из схемы однослойной нейронной сети, представленной справа, сигналы <tex>x_1, x_2, \ldots x_n</tex> поступают на входной слой (который не считается за слой нейронной сети), а затем сигналы распределяются на выходной слой обычных нейронов. На каждом ребре от нейрона входного слоя к нейрону выходного слоя написано число {{---}} вес соответствующей связи.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
===Многослойные нейронные сети===<br />
<br />
[[File:Multi-layer-neural-net-scheme.png|500px|thumb|[https://wiki.loginom.ru/articles/multilayer-neural-net.html Схема многослойной нейронной сети]]]<br />
<br />
'''Многослойная нейронная сеть''' (англ. ''Multilayer neural network'') {{---}} нейронная сеть, состоящая из входного, выходного и расположенного(ых) между ними одного (нескольких) скрытых слоев нейронов.<br />
<br />
Помимо входного и выходного слоев эти нейронные сети содержат промежуточные, ''скрытые слои''. Такие сети обладают гораздо большими возможностями, чем однослойные нейронные сети, однако методы обучения нейронов скрытого слоя были разработаны относительно недавно.<br />
<br />
Работу скрытых слоев нейронов можно сравнить с работой большого завода. Продукт (выходной сигнал) на заводе собирается по стадиям на станках. После каждого станка получается какой-то промежуточный результат. Скрытые слои тоже преобразуют входные сигналы в некоторые промежуточные результаты.<br />
<br />
<br />
<br />
===Сети прямого распространения===<br />
<br />
'''Сети прямого распространения''' (англ. ''Feedforward neural network'') (feedforward сети) {{---}} искусственные нейронные сети, в которых сигнал распространяется строго от входного слоя к выходному. В обратном направлении сигнал не распространяется.<br />
<br />
Все сети, описанные выше, являлись сетями прямого распространения, как следует из определения. Такие сети широко используются и вполне успешно решают определенный класс задач: прогнозирование, кластеризация и распознавание.<br />
<br />
Однако сигнал в нейронных сетях может идти и в обратную сторону.<br />
<br />
===Сети с обратными связями===<br />
<br />
[[File:Сети_с_обратными_связями.png|400px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%A1%D0%B5%D1%82%D0%B8-%D1%81-%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%BC%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8F%D0%BC%D0%B8 Схема сети с обратными связями]]]<br />
<br />
'''[[Рекуррентные нейронные сети|Сети с обратными связями]]''' (англ. ''Recurrent neural network'') {{---}} искусственные нейронные сети, в которых выход нейрона может вновь подаваться на его вход. В более общем случае это означает возможность распространения сигнала от выходов к входам.<br />
<br />
В сетях прямого распространения выход сети определяется входным сигналом и весовыми коэффициентами при искусственных нейронах. В сетях с обратными связями выходы нейронов могут возвращаться на входы. Это означает, что выход какого-нибудь нейрона определяется не только его весами и входным сигналом, но еще и предыдущими выходами (так как они снова вернулись на входы).<br />
<br />
==Обучение нейронной сети==<br />
<br />
'''Обучение нейронной сети''' {{---}} поиск такого набора весовых коэффициентов, при котором входной сигнал после прохода по сети преобразуется в нужный нам выходной.<br />
<br />
Это определение «обучения нейронной сети» соответствует и биологическим нейросетям. Наш мозг состоит из огромного количества связанных друг с другом нейросетей, каждая из которых в отдельности состоит из нейронов одного типа (с одинаковой функцией активации). Наш мозг обучается благодаря изменению синапсов {{---}} элементов, которые усиливают или ослабляют входной сигнал.<br />
<br />
Если обучать сеть, используя только один входной сигнал, то сеть просто «запомнит правильный ответ», а как только мы подадим немного измененный сигнал, вместо правильного ответа получим бессмыслицу. Мы ждем от сети способности ''обобщать'' какие-то признаки и решать задачу на различных входных данных. Именно с этой целью и создаются ''обучающие выборки''.<br />
<br />
'''Обучающая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит обучение сети.<br />
<br />
После обучения сети, то есть когда сеть выдает корректные результаты для всех входных сигналов из обучающей выборки, ее можно использовать на практике. Однако прежде чем сразу использовать нейронную сеть, обычно производят оценку качества ее работы на так называемой ''тестовой выборке''.<br />
<br />
'''Тестовая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит оценка качества работы сети.<br />
<br />
Само обучение нейронной сети можно разделить на два подхода: [[Обучение с учителем|обучение с учителем]]<sup>[на 28.01.19 не создан]</sup> и [[Обучение без учителя|обучение без учителя]]<sup>[на 28.01.19 не создан]</sup>. В первом случае веса меняются так, чтобы ответы сети минимально отличались от уже готовых правильных ответов, а во втором случае сеть самостоятельно классифицирует входные сигналы.<br />
<br />
==Перцептрон==<br />
<br />
[[File:Перцептрон.png|350px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9F%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема перцептрона]]]<br />
<br />
'''Перцептрон''' (англ. ''Perceptron'') {{---}} простейший вид нейронных сетей. В основе лежит математическая модель восприятия информации мозгом, состоящая из сенсоров, ассоциативных и реагирующих элементов.<br />
<br />
===История===<br />
<br />
Идею перцептрона предложил нейрофизиолог Фрэнк Розенблатт. Он предложил схему устройства, моделирующего процесс человеческого восприятия, и назвал его ''«перцептроном»'' (от латинского ''perceptio'' {{---}} восприятие). В 1960 году Розенблатт представил первый нейрокомпьютер {{---}} «Марк-1», который был способен распознавать некоторые буквы английского алфавита.<br />
<br />
Таким образом перцептрон является одной из первых '''моделей нейросетей''', а «Марк-1» {{---}} первым в мире '''нейрокомпьютером'''.<br />
<br />
===Описание===<br />
<br />
В основе перцептрона лежит математическая модель восприятия информации мозгом. Разные исследователи по-разному его определяют. В самом общем своем виде (как его описывал Розенблатт) он представляет систему из элементов трех разных типов: сенсоров, ассоциативных элементов и реагирующих элементов.<br />
<br />
Принцип работы перцептрона следующий:<br />
# Первыми в работу включаются S-элементы. Они могут находиться либо в состоянии покоя (сигнал равен ''0''), либо в состоянии возбуждения (сигнал равен ''1'');<br />
# Далее сигналы от S-элементов передаются A-элементам по так называемым S-A связям. Эти связи могут иметь веса, равные только ''-1'', ''0'' или ''1'';<br />
# Затем сигналы от сенсорных элементов, прошедших по S-A связям, попадают в A-элементы, которые еще называют ассоциативными элементами;<br />
#* Одному A-элементу может соответствовать несколько S-элементов;<br />
#* Если сигналы, поступившие на A-элемент, в совокупности превышают некоторый его порог <tex>\theta</tex>, то этот A-элемент возбуждается и выдает сигнал, равный ''1'';<br />
#* В противном случае (сигнал от S-элементов не превысил порога A-элемента), генерируется нулевой сигнал;<br />
# Далее сигналы, которые произвели возбужденные A-элементы, направляются к сумматору (R-элемент), действие которого нам уже известно. Однако, чтобы добраться до R-элемента, они проходят по A-R связям, у которых тоже есть веса (которые уже могут принимать любые значения, в отличие от S-A связей);<br />
# R-элемент складывает друг с другом взвешенные сигналы от A-элементов, а затем<br />
#* если превышен определенный порог, генерирует выходной сигнал, равный ''1'';<br />
#* eсли порог не превышен, то выход перцептрона равен ''-1''.<br />
<br />
Для элементов перцептрона используют следующие названия:<br />
* S-элементы называют сенсорами;<br />
* A-элементы называют ассоциативными;<br />
* R-элементы называют реагирующими.<br />
<br />
===Классификация перцептронов===<br />
<br />
[[File:Однслойный_перцептрон.png|300px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9-%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема однослойного перцептрона]]]<br />
<br />
'''Перцептрон с одним скрытым слоем''' ('''элементарный перцептрон''', англ. ''elementary perceptron'') {{---}} перцептрон, у которого имеется только по одному слою S, A и R элементов.<br />
<br />
'''Однослойный персептрон''' (англ. ''Single-layer perceptron'') {{---}} перцептрон, каждый S-элемент которого однозначно соответствует одному А-элементу, S-A связи всегда имеют вес ''1'', а порог любого А-элемента равен ''1''. Часть однослойного персептрона соответствует модели искусственного нейрона.<br />
<br />
Его ключевая особенность состоит в том, что каждый S-элемент однозначно соответствует одному A-элементу, все S-A связи имеют вес, равный ''+1'', а порог A элементов равен ''1''. Часть однослойного перцептрона, не содержащая входы, соответствует искусственному нейрону, как показано на картинке. Таким образом, однослойный перцептрон {{---}} это искусственный нейрон, который на вход принимает только ''0'' и ''1''.<br />
<br />
Однослойный персептрон также может быть и элементарным персептроном, у которого только по одному слою S,A,R-элементов.<br />
<br />
'''Многослойный перцептрон по Розенблатту''' (англ. ''Rosenblatt multilayer perceptron'') {{---}} перцептрон, который содержит более 1 слоя А-элементов.<br />
<br />
'''Многослойный перцептрон по Румельхарту''' (англ. ''Rumelhart multilater perceptron'') {{---}} частный случай многослойного персептрона по Розенблатту, с двумя особенностями:<br />
* S-A связи могут иметь произвольные веса и обучаться наравне с A-R связями;<br />
* Обучение производится по специальному алгоритму, который называется обучением по методу обратного распространения ошибки.<br />
<br />
===Обучение перцептрона===<br />
<br />
Задача обучения перцептрона {{---}} подобрать такие <tex>w_0, w_1, w_2, \ldots, w_n</tex>, чтобы <tex>sign(\sigma(w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n))</tex> как можно чаще совпадал с <tex>y(x)</tex> {{---}} значением в обучающей выборке (здесь <tex>\sigma</tex> {{---}} функция активации). Для удобства, чтобы не тащить за собой свободный член <tex>w_0</tex>, добавим в вектор $x$ лишнюю «виртуальную размерность» и будем считать, что <tex>x = (1, x_1, x_2, \ldots, x_n)</tex>. Тогда <tex>w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n</tex> можно заменить на <tex>w^T \cdot x</tex>.<br />
<br />
Чтобы обучать эту функцию, сначала надо выбрать функцию ошибки, которую потом можно оптимизировать [[Стохастический градиентный спуск|градиентным спуском]]. Число неверно классифицированных примеров не подходит на эту кандидатуру, потому что эта функция кусочно-гладкая, с массой разрывов: она будет принимать только целые значения и резко меняться при переходе от одного числа неверно классифицированных примеров к другому. Поэтому использовать будем другую функцию, так называемый ''критерий перцептрона'': <tex>E_P(w) = -\sum_{x \in M} y(x)(\sigma(w^T \cdot x))</tex>, где <tex>M</tex> {{---}} множество примеров, которые перцептрон с весами <tex>w</tex> классифицирует неправильно.<br />
<br />
Иначе говоря, мы минимизируем суммарное отклонение наших ответов от правильных, но только в неправильную сторону; верный ответ ничего не вносит в функцию ошибки. Умножение на <tex>y(x)</tex> здесь нужно для того, чтобы знак произведения всегда получался отрицательным: если правильный ответ ''−1'', значит, перцептрон выдал положительное число (иначе бы ответ был верным), и наоборот. В результате у нас получилась кусочно-линейная функция, дифференцируемая почти везде, а этого вполне достаточно.<br />
<br />
Теперь <tex>E_P(w)</tex> можно оптимизировать градиентным спуском. На очередном шаге получаем: <tex>w^{(\tau+1)} = w^{(\tau)} − \eta\triangledown_w E_P(w)</tex>.<br />
<br />
Алгоритм такой {{---}} мы последовательно проходим примеры <tex>x_1, x_2, \ldots</tex> из обучающего множества, и для каждого <tex>x_n</tex>:<br />
* если он классифицирован правильно, не меняем ничего;<br />
* а если неправильно, прибавляем <tex>\eta \triangledown_w E_P(w)</tex>.<br />
<br />
Ошибка на примере <tex>x_n</tex> при этом, очевидно, уменьшается, но, конечно, совершенно никто не гарантирует, что вместе с тем не увеличится ошибка от других примеров. Это правило обновления весов так и называется {{---}} правило обучения перцептрона, и это было основной математической идеей работы Розенблатта.<br />
<br />
===Применение===<br />
<br />
* Решение задач классификации, если объекты классификации обладают свойством линейной разделимости;<br />
* Прогнозирование и распознавание образов;<br />
* Управление агентами<ref>[https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D0%BE%D0%B2 Применения перцептрона, Wikipedia]</ref>.<br />
<br />
===Пример использования с помощью scikit-learn<ref>[https://scikit-learn.org Библиотека scikit-learn для Python]</ref>===<br />
<br />
Будем классифицировать с помощью перцептрона датасет MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>.<br />
<br />
# Load required libraries<br />
from sklearn import datasets<br />
from sklearn.preprocessing import StandardScaler<br />
from sklearn.linear_model import Perceptron #Single-layer perceptron<br />
from sklearn.neural_network import MLPClassifier #Multilayer perceptron <br />
from sklearn.model_selection import train_test_split<br />
from sklearn.metrics import accuracy_score<br />
import numpy as np<br />
<br />
# Load the mnist dataset<br />
mnist = datasets.load_digits()<br />
<br />
# Create our X and y data<br />
n_samples = len(mnist.images)<br />
X = mnist.images.reshape((n_samples, -1))<br />
y = mnist.target<br />
<br />
# Split the data into 70% training data and 30% test data<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)<br />
<br />
# Train the scaler, which standarizes all the features to have mean=0 and unit variance<br />
sc = StandardScaler()<br />
sc.fit(X_train)<br />
<br />
# Apply the scaler to the X training data<br />
X_train_std = sc.transform(X_train)<br />
<br />
# Apply the SAME scaler to the X test data<br />
X_test_std = sc.transform(X_test)<br />
<br />
# Create a single-layer perceptron object with the parameters: 40 iterations (epochs) over the data, and a learning rate of 0.1<br />
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)<br />
# Create a multilayer perceptron object<br />
mppn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(256, 512, 128), random_state=1)<br />
<br />
# Train the perceptrons<br />
ppn.fit(X_train_std, y_train)<br />
mppn.fit(X_train_std, y_train)<br />
<br />
# Apply the trained perceptrons on the X data to make predicts for the y test data<br />
y_pred = ppn.predict(X_test_std)<br />
multi_y_pred = mppn.predict(X_test_std)<br />
<br />
# View the accuracies of the model, which is: 1 - (observations predicted wrong / total observations)<br />
print('Single-layer perceptron accuracy: %.4f' % accuracy_score(y_test, y_pred))<br />
print('Multilayer perceptron accuracy: %.4f' % accuracy_score(y_test, multi_y_pred))<br />
<br />
Вывод:<br />
Single-layer perceptron accuracy: 0.9574<br />
Multilayer perceptron accuracy: 0.9759<br />
<br />
===Пример использования с помощью tensorflow<ref>[https://www.tensorflow.org/ Библиотека tensorflow для Python]</ref>===<br />
<br />
Будем классифицировать цифры из того же датасета MNIST.<br />
<br />
# Load required libraries<br />
import tensorflow as tf<br />
from tensorflow.examples.tutorials.mnist import input_data<br />
<br />
#Load MNIST dataset<br />
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)<br />
<br />
#placeholder for test data<br />
x = tf.placeholder(tf.float32, [None, 784])<br />
#placeholder for weights and bias<br />
W = tf.Variable(tf.zeros([784, 10]))<br />
b = tf.Variable(tf.zeros([10]))<br />
#tensorflow model<br />
y = tf.nn.softmax(tf.matmul(x, W) + b)<br />
<br />
#loss function<br />
y_ = tf.placeholder(tf.float32, [None, 10])<br />
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))<br />
<br />
#gradient descent step<br />
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)<br />
<br />
init = tf.initialize_all_variables()<br />
sess = tf.Session()<br />
sess.run(init)<br />
for i in range(1000):<br />
batch_xs, batch_ys = mnist.train.next_batch(100)<br />
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})<br />
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))<br />
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))<br />
print("Accuracy: %s" % sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))<br />
<br />
[[File:Tensorflow-mnist-failures.png|400px|thumb|Правильные метки {{---}} 5, 4, 9, 7. Результат классификации {{---}} 6, 6, 4, 4.]]<br />
<br />
Вывод:<br />
Accuracy: 0.9164<br />
<br />
<br />
На рисунке справа показаны четыре типичных изображения, на которых классификаторы ошибаются. Согласитесь, случаи действительно тяжелые.<br />
<br />
==См. также==<br />
*[[:Сверточные нейронные сети|Сверточные нейронные сети]]<br />
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]<br />
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]<sup>[на 28.01.19 не создан]</sup><br />
<br />
==Примечания==<br />
<references/><br />
== Источники информации ==<br />
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 93-123.<br />
* [https://neuralnet.info/book/ Нейронные сети {{---}} учебник ]<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Нейронные сети]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%B2%D0%B5%D1%80%D1%82%D0%BE%D1%87%D0%BD%D1%8B%D0%B5_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8&diff=69685Сверточные нейронные сети2019-01-30T20:32:29Z<p>Dariyakovleva: </p>
<hr />
<div>'''Сверточная нейронная сеть''' (англ. ''convolutional neural network'', ''CNN'') {{---}} специальная архитектура нейронных сетей, предложенная Яном Лекуном<ref name=LeNet5>[http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf Yann LeCun — Gradient-Based Learning Applied to Document Recognition, 1998]</ref>, изначально нацеленная на эффективное распознавание изображений.<br />
<br />
== Свертка ==<br />
[[Файл:Convolution_example.png|upright=1.0|thumb|[https://arxiv.org/abs/1603.07285 Пример свертки двух матриц размера 5x5 и 3x3]]]<br />
'''Свертка''' (англ. ''convolution'') {{---}} операция над парой матриц <math>A</math> (размера <math>n_x\times n_y</math>) и <math>B</math> (размера <math>m_x \times m_y</math>), результатом которой является матрица <math>C = A * B</math> размера <math>(n_x-m_x+1)\times (n_y-m_y+1)</math>.<br />
Каждый элемент результата вычисляется как скалярное произведение матрицы <math>B</math> и некоторой подматрицы <math>A</math> такого же размера (подматрица определяется положением элемента в результате).<br />
То есть, <math>C_{i,j} = \sum_{u = 0}^{m_x-1}\sum_{v = 0}^{m_y - 1}A_{i+u,j+v}B_{u,v}</math>. На изображении справа можно видеть, как матрица <math>B</math> «двигается» по матрице <math>A</math>, и в каждом положении считается скалярное произведение матрицы <math>B</math> и той части матрицы <math>A</math>, на которую она сейчас наложена. Получившееся число записывается в соответствующий элемент результата.<br />
<br />
Логический смысл свертки такой {{---}} чем больше величина элемента свертки, тем больше эта часть матрицы <math>A</math> была похожа на матрицу <math>B</math> (похожа в смысле скалярного произведения). Поэтому матрицу <math>A</math> называют ''изображением'', а матрицу <math>B</math> {{---}} ''фильтром'' или ''образцом''.<br />
<br />
== Структура сверточной нейронной сети ==<br />
В сверточной нейронной сети выходы промежуточных слоев образуют матрицу (изображение) или набор матриц (несколько слоёв изображения). Так, например, на вход сверточной нейронной сети можно подавать три слоя изображения (R-, G-, B-каналы изображения). Основными видами слоев в сверточной нейронной сети являются сверточные слои (англ. ''convolutional layer''), пулинговые слои (англ. ''pooling layer'') и [[:Нейронные_сети,_перцептрон|полносвязные слои]] (англ. ''fully-connected layer'').<br />
<br />
=== Сверточный слой ===<br />
[[Файл:Padding.png|upright=1.0|thumb|[https://arxiv.org/abs/1603.07285 Пример свертки двух матриц с дополнением нулями и сдвигом 2]]]<br />
[[Файл:Convolution-operation-on-volume5.png|upright=1.0|thumb|[http://www.machinelearning.ru/wiki/images/1/1b/DL16_lecture_3.pdf Пример свертки с трехмерным ядром]]]<br />
Сверточный слой нейронной сети представляет из себя применение операции свертки к выходам с предыдущего слоя, где веса ядра свертки являются обучаемыми параметрами. Еще один обучаемый вес используется в качестве константного сдвига (англ. ''bias''). При этом есть несколько важных деталей:<br />
<br />
* В одном сверточном слое может быть несколько сверток. В этом случае для каждой свертки на выходе получится своё изображение. Например, если вход имел размерность <math>w\times h</math>, а в слое было <math>n</math> сверток с ядром размерности <math>k_x\times k_y</math>, то выход будет иметь размерность <math>n\times(w - k_x + 1)\times(h - k_y + 1)</math>;<br />
<br />
* Ядра свертки могут быть трёхмерными. Свертка трехмерного входа с трехмерным ядром происходит аналогично, просто скалярное произведение считается еще и по всем слоям изображения. Например, для усреднения информации о цветах исходного изображения, на первом слое можно использовать свертку размерности <math>3\times w \times h</math>. На выходе такого слоя будет уже одно изображение (вместо трёх);<br />
<br />
* Можно заметить, что применение операции свертки уменьшает изображение. Также пиксели, которые находятся на границе изображения участвуют в меньшем количестве сверток, чем внутренние. В связи с этим в сверточных слоях используется дополнение изображения (англ. ''padding''). Выходы с предыдущего слоя дополняются пикселями так, чтобы после свертки сохранился размер изображения. Такие свертки называют ''одинаковыми'' (англ. ''same convolution''), а свертки без дополнения изображения называются ''правильными'' (англ. ''valid convolution''). Среди способов, которыми можно заполнить новые пиксели, можно выделить следующие:<br />
** ''zero shift'': <code>00[ABC]00</code>;<br />
** ''border extension'': <code>AA[ABC]CC</code>;<br />
** ''mirror shift'': <code>BA[ABC]CB</code>;<br />
** ''cyclic shift'': <code>BC[ABC]AB</code>.<br />
<br />
* Еще одним параметром сверточного слоя является ''сдвиг'' (англ. ''stride''). Хоть обычно свертка применяется подряд для каждого пикселя, иногда используется сдвиг, отличный от единицы {{---}} скалярное произведение считается не со всеми возможными положениями ядра, а только с положениями, кратными некоторому сдвигу <math>s</math>. Тогда, если если вход имел размерность <math>w\times h</math>, а ядро свертки имело размерность <math>k_x\times k_y</math> и использовался сдвиг <math>s</math>, то выход будет иметь размерность <math>\lfloor\frac{w - k_x}{s} + 1\rfloor\times\lfloor\frac{h - k_y}{s} + 1\rfloor</math>.<br />
<br />
<br />
=== Пулинговый слой ===<br />
[[Файл:Maxpool.jpeg|upright=1.0|thumb|[https://www.slideshare.net/YUNGKUEICHEN/convolutional-neural-network-cnn-image-recognition Пример операции пулинга с функцией максимума]]]<br />
Пулинговый слой призван снижать размерность изображения. Исходное изображение делится на блоки размером <math>w\times h</math> и для каждого блока вычисляется некоторая функция. Чаще всего используется функция максимума (англ. ''max pooling'') или (взвешенного) среднего (англ. ''(weighted) average pooling''). Обучаемых параметров у этого слоя нет. Основные цели пулингового слоя:<br />
* уменьшение изображения, чтобы последующие свертки оперировали над большей областью исходного изображения;<br />
* увеличение инвариантности выхода сети по отношению к малому переносу входа;<br />
* ускорение вычислений.<br />
<br />
=== Inception module ===<br />
[[Файл:Inception.png|upright=1.0|thumb|[https://arxiv.org/abs/1409.4842 Inception module]]]<br />
[[Файл:Inception_red.png|upright=1.0|thumb|[https://arxiv.org/pdf/1409.4842.pdf Inception module с сокращением размерностей]]]<br />
''Inception module'' {{---}} это специальный слой нейронной сети, который был предложен в работе<ref name=GoogLeNet>[https://arxiv.org/pdf/1409.4842.pdf Going deeper with convolutions]</ref>, в которой была представлена сеть GoogLeNet. Основная цель этого модуля заключается в следующем. Авторы предположили, что каждый элемент предыдущего слоя соответствует определенной области исходного изображения. Каждая свертка по таким элементам будет увеличивать область исходного изображения, пока элементы на последних слоях не будут соответствовать всему изображению целиком. Однако, если с какого-то момента все свертки станут размером <math>1\times 1</math>, то не найдется элементов, которые покрывали бы все исходное изображение, поэтому было бы невозможно находить большие признаки на изображении. Чтобы решить эту проблему, авторы предложили так называемый inception module {{---}} конкатенацию выходов для сверток размера <math>1\times 1</math>, <math>3\times 3</math>, <math>5\times 5</math>, а также операции max pooling'а с ядром <math>3\times 3</math>. К сожалению, подобный наивный подход (англ. ''naive inception module'') приводит к резкому увеличению слоев изображения, что не позволяет построить с его использованием глубокую нейронную сеть. Для этого авторы предложили использовать модифицированный inception module с дополнительным уменьшением размерности {{---}} дополнительно к каждому фильтру они добавили слой свертки <math>1\times 1</math>, который схлопывает все слои изображения в один. Это позволяет сохранить малое число слоев, с сохранением полезной информации о изображении.<br />
<br />
=== Residual block ===<br />
[[Файл:Residual.png|upright=1.0|thumb|[https://arxiv.org/pdf/1512.03385.pdf Устройство residual block]]]<br />
Двумя серьезными проблемами в обучении глубоких нейронных сетей являются исчезающий градиент (англ. ''vanishing gradient'') и взрывающийся градиент (англ. ''exploding gradient''). Они возникают из-за того, что при дифференцировании по цепному правилу, до глубоких слоев нейронной сети доходит очень маленькая величина градиента (из-за многократного домножения на небольшие величины на предыдущих слоях). Для борьбы с этой проблемой был предложен так называемый ''residual block''<ref name=ResNet>[https://arxiv.org/pdf/1512.03385.pdf Deep residual learning for image recognition]</ref>. Идея заключается в том, чтобы взять пару слоёв (например, сверточных), и добавить дополнительную связь, которая проходит мимо этих слоёв. Пусть <math>z^{(k)}</math> {{---}} выход <math>k</math>-ого слоя до применения функции активации, а <math>a^{(k)}</math> {{---}} выход после. Тогда residual block будет выполнять следующее преобразование: <math>a^{(k + 2)} = g(z^{(k + 2)} + a^{(k)})</math>, где <math>g</math> {{---}} функция активации.<br />
<br />
На самом деле, такая нейронная сеть обучается предсказывать функцию <math>\mathcal{F}(x) - x</math>, вместо функции <math>\mathcal{F}(x)</math>, которую изначально нужно было предсказывать. Для компенсации этой разницы и вводится это замыкающее соединение (англ. ''shortcut connection''), которое добавляет недостающий <math>x</math> к функции. Предположение авторов, которые предложили residual block, заключалось в том, что такую разностную функцию будет проще обучать, чем исходную. Если рассматривать крайние случаи, то если <math>\mathcal{F}(x) = x</math>, такую сеть обучить нулю всегда возможно, в отличие от обучения множества нелинейных слоёв линейному преобразованию.<br />
<br />
== Известные архитектуры сверточных нейронных сетей ==<br />
=== LeNet-5 ===<br />
[[Файл:Lenet5.png|upright=1.0|thumb|[http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf Архитектура LeNet-5]]]<br />
Нейронная сеть, предложенная Яном Лекуном<ref name=LeNet5/>, для распознавания рукописных цифр MNIST.<br />
<br />
=== AlexNet ===<br />
[[Файл:Alexnet.png|upright=1.0|thumb|[https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf Архитектура AlexNet]]]<br />
Победитель соревнования ImageNet 2012-ого года, набравший точность 84.6%<ref name=AlexNet>[https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf ImageNet Classification with Deep Convolutional Neural Networks]</ref>. Была реализована с использованием CUDA для повышения производительности. Состоит из двух отдельных частей, которые слабо взаимодействуют друг с другом, что позволяет исполнять их параллельно на разных GPU с минимальным обменом данными.<br />
<br />
=== VGG ===<br />
Семейство архитектур нейронных сетей, которое включает в себя, в частности, VGG-11, VGG-13, VGG-16 и VGG-19<ref name=VGG>[https://arxiv.org/pdf/1409.1556.pdf Very Deep Convolutional Networks for Large-Scale Image Recognition]</ref>. Победитель соревнования ImageNet 2013-ого года (VGG-16), набравший точность 92.7%. Одной из отличительных особенностей является использование ядер свертки небольшого размера (3x3, в отличие от больших ядер размера 7x7 или 11x11).<br />
<br />
=== GoogLeNet ===<br />
Также известный как ''inception network'' {{---}} победитель соревнования ImageNet 2014-ого года, набравший 93.3% точности<ref name=GoogLeNet/>. Состоит в основном из inception модулей. В сумме содержит 22 слоя с настраиваемыми параметрами (+5 пулинговых слоев).<br />
<br />
=== ResNet ===<br />
Победитель соревнования ImageNet 2015-ого года. Сеть-победитель содержала более 150 слоёв<ref name=ResNet/> и набрала 96.43% точности.<br />
<br />
=== Сравнение известных нейронных сетей ===<br />
[[Файл:Net-comparison.png|border|1000px]]<br />
<br />
== Примеры кода ==<br />
===Scala===<br />
Пример кода с библиотекой DeepLearning.scala<ref>[https://deeplearning.thoughtworks.school/index.html DeepLearning.scala]</ref><br />
// Загрузка датасета<br />
val cifar10 = Cifar10.load().blockingAwait<br />
// Определение слоёв<br />
def myNeuralNetwork(input: INDArray): INDArrayLayer = {<br />
val cnnLayer = maxPool(relu(conv2d(input.reshape(input.shape()(0), Cifar10.NumberOfChannels, PixelHeight, PixelWidth), cnnWeight, cnnBias, (KernelHeight, KernelWidth), (Stride, Stride), (Padding, Padding))), (PoolSize, PoolSize))<br />
val affineRuleOfCnnLayer = relu(affine(cnnLayer.reshape(input.shape()(0), NumFilters * (PixelHeight / PoolSize) * (PixelWidth / PoolSize)), affineWeight, affineBias))<br />
val affineOfaffineRuleOfCnnLayer = affine(affineRuleOfCnnLayer.reshape(input.shape()(0), HiddenDim), affineLastWeight, affineLastBias)<br />
val softmaxValue = softmax(affineOfaffineRuleOfCnnLayer)<br />
softmaxValue<br />
}<br />
// Определение функции потерь<br />
def lossFunction(input: INDArray, expectOutput: INDArray): DoubleLayer = { <br />
val probabilities = myNeuralNetwork(input)<br />
-(hyperparameters.log(probabilities) * expectOutput).mean <br />
}<br />
<br />
class Trainer(batchSize: Int, numberOfEpoches: Int = 5) {<br />
import scalaz.std.anyVal._<br />
import scalaz.syntax.all._<br />
@volatile<br />
private var isShuttingDown: Boolean = false<br />
private val lossBuffer = scala.collection.mutable.Buffer.empty[Double]<br />
def plotLoss(): Unit = Seq(Scatter(lossBuffer.indices, lossBuffer)).plot(title = "loss by time")<br />
def interrupt(): Unit = isShuttingDown = true<br />
def startTrain(): Unit = {<br />
@monadic[Future]<br />
def trainTask: Future[Unit] = {<br />
isShuttingDown = false<br />
var epoch = 0<br />
<br />
while (epoch < numberOfEpoches && !isShuttingDown) {<br />
val cifar10 = Cifar10.load().blockingAwait<br />
val iterator = cifar10.epoch(batchSize).zipWithIndex<br />
while (iterator.hasNext && !isShuttingDown) {<br />
val (Cifar10.Batch(labels, batch), i) = iterator.next()<br />
val loss = lossFunction(batch, labels).train.each<br />
lossBuffer += loss<br />
hyperparameters.logger.info(s"epoch=epoch iteration=i batchSize=batchSize loss=loss")<br />
}<br />
epoch += 1<br />
}<br />
hyperparameters.logger.info("Done")<br />
}<br />
trainTask.onComplete { tryUnit: scala.util.Try[Unit] => tryUnit.get }<br />
}<br />
}<br />
<br />
==См. также==<br />
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]<br />
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]<br />
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]<sup>[на 28.01.19 не создан]</sup><br />
<br />
==Примечания==<br />
<references/><br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Нейронные сети]]<br />
[[Категория: Сверточные нейронные сети]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A0%D0%B5%D0%BA%D1%83%D1%80%D1%80%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B5_%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8&diff=69684Рекуррентные нейронные сети2019-01-30T20:31:02Z<p>Dariyakovleva: </p>
<hr />
<div>'''Рекуррентная нейронная сеть''' (англ. ''recurrent neural network'', ''RNN'') {{---}} вид [[:Нейронные_сети,_перцептрон|нейронных сетей]], где связи между элементами образуют направленную последовательность.<br />
<br />
== Описание ==<br />
[[File:RNN.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ RNN и ее развернутое представление]]]<br />
[[File:RNN_layer.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоя рекуррентной сети]]]<br />
Рекуррентные нейронные сети {{---}} сети с циклами, которые хорошо подходят для обработки последовательностей.<br />
[[File:RNN_BP.jpg|450px|thumb|RNN с задержкой на скрытом слое]]<br />
[[File:RNN_BPTT.jpg|450px|thumb|Развертка RNN]]<br />
Обучение RNN аналогично обучению обычной нейронной сети. Мы также используем [[:Обратное_распространение_ошибки|алгоритм обратного распространения ошибки (backpropagation)]]<sup>[на 28.01.19 не создан]</sup>, но с небольшим изменением. Поскольку одни и те же параметры используются на всех временных этапах в сети, градиент на каждом выходе зависит не только от расчетов текущего шага, но и от предыдущих временных шагов. Например, чтобы вычислить градиент для четвертого элемента последовательности, нам нужно было бы «распространить ошибку» на 3 шага и суммировать градиенты. Этот алгоритм называется «алгоритмом обратного распространения ошибки сквозь время» (англ. Backpropagation Through Time, BPTT).<ref name=BPTT_1>[http://andrew.gibiansky.com/blog/machine-learning/recurrent-neural-networks/ Backpropagation Through Time]</ref><ref name=BPTT_2>[http://www.wildml.com/2015/10/recurrent-neural-networks-tutorial-part-3-backpropagation-through-time-and-vanishing-gradients/ Backpropagation Through Time]</ref><br />
<br />
Алгоритм обратного распространения ошибки сквозь время:<br />
<br />
[[File:RNN_BPTT_GRAD.png|400px|frameless]]<br />
<br />
== Области и примеры применения ==<br />
Используются, когда важно соблюдать последовательность, когда важен порядок поступающих объектов.<br />
* Обработка текста на естественном языке:<br />
** Анализ текста;<br />
** Автоматический перевод;<br />
* Обработка аудио:<br />
** Автоматическое распознавание речи;<br />
* Обработка видео:<br />
** Прогнозирование следующего кадра на основе предыдущих;<br />
** Распознавание эмоций;<br />
* Обработка изображений:<br />
** Прогнозирование следующего пикселя на основе окружения;<br />
** Генерация описания изображений.<br />
<br />
== Виды RNN ==<br />
=== Один к одному ===<br />
{|<br />
|-<br />
|[[File:RNN_OTO.jpg|100px|left]]<br />
|Архитектура по сути является обычной нейронной сетью.<br />
|}<br />
<br />
=== Один ко многим ===<br />
{|<br />
|-<br />
|[[File:RNN_OTM.jpg|100px|left]]<br />
|Один вход ко многим выходам может применяться, например, для генерации аудиозаписи. На вход подаем жанр музыки, который хотим получить, на выходе получаем последовательность аудиозаписи.<br />
|}<br />
<br />
=== Многие к одному ===<br />
{|<br />
|-<br />
|[[File:RNN_MTO.jpg|100px|left]]<br />
|Много входов и один выход может применяться, если мы хотим оценить тональность рецензии. На вход подаем слова рецензии, на выходе получаем оценку ее тональности: позитивная рецензия или негативная.<br />
|}<br />
<br />
=== Многие ко многим ===<br />
{|<br />
|-<br />
|[[File:RNN_MTM1.jpg|100px|left]]<br />
|Данную архитектуру можно использовать для перевода текста с одного языка на другой.<br />
|-<br />
|[[File:RNN_MTM2.jpg|100px|left]]<br />
|Такой вариант подойдет для определения для классификации каждого слова в предложении в зависимости от контекста.<br />
|}<br />
<br />
== Архитектуры ==<br />
=== Полностью рекуррентная сеть ===<br />
Это базовая архитектура, разработанная в 1980-х. Сеть строится из узлов, каждый из которых соединён со всеми другими узлами. У каждого нейрона порог активации меняется со временем и является вещественным числом. Каждое соединение имеет переменный вещественный вес. Узлы разделяются на входные, выходные и скрытые.<br />
<br />
=== Рекурсивная сеть ===<br />
[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]<sup>[на 28.01.19 не создан]</sup> представляют собой более общий случай рекуррентных сетей, когда сигнал в сети проходит через структуру в виде дерева (обычно бинарные деревья). Те же самые матрицы весов используются рекурсивно по всему графу в соответствии с его топологией.<br />
<br />
=== Нейронная сеть Хопфилда ===<br />
Тип рекуррентной сети, когда все соединения симметричны. Изобретена Джоном Хопфилдом в 1982 году и гарантируется, что динамика такой сети сходится к одному из положений равновесия.<br />
<br />
=== Двунаправленная ассоциативная память (BAM) ===<br />
Вариацией сети Хопфилда является двунаправленная ассоциативная память (BAM). BAM имеет два слоя, каждый из которых может выступать в качестве входного, находить (вспоминать) ассоциацию и генерировать результат для другого слоя.<br />
[[File:Elman_RNN.jpg|450px|thumb|Сеть Элмана]]<br />
<br />
=== Сеть Элмана ===<br />
Нейронная сеть Элмана состоит из трёх слоев: x, y, z (см рис. Сеть Элмана). Дополнительно к сети добавлен набор «контекстных блоков»: u (см рис. Сеть Элмана). Средний (скрытый) слой соединён с контекстными блоками с фиксированным весом, равным единице. С каждым шагом времени на вход поступает информация, которая проходит прямой ход к выходному слою в соответствии с правилами обучения. Фиксированные обратные связи сохраняют предыдущие значения скрытого слоя в контекстных блоках (до того как скрытый слой поменяет значение в процессе обучения). Таким способом сеть сохраняет своё состояние, что может использоваться в предсказании последовательностей, выходя за пределы мощности многослойного перцептрона.<br />
<br />
<math>h_t = \sigma_h(W_h x_t + U_h h_{t-1} + b_h)</math>,<br />
<br />
<math>y_t = \sigma_y(W_y h_t + b_y)</math>,<br />
<br />
Обозначения переменных и функций:<br />
* <math>x_t</math>: вектор входного слоя;<br />
* <math>h_t</math>: вектор скрытого слоя;<br />
* <math>y_t</math>: вектор выходного слоя;<br />
* <math>W, U, b</math>: матрица и вектор параметров;<br />
* <math>\sigma_h, \sigma_y</math>: функция активации.<br />
<br />
=== Сеть Джордана ===<br />
Нейронная сеть Джордана подобна сети Элмана, но контекстные блоки связаны не со скрытым слоем, а с выходным слоем. Контекстные блоки таким образом сохраняют своё состояние. Они обладают рекуррентной связью с собой.<br />
<br />
<math>h_t = \sigma_h(W_h x_t + U_h y_{t-1} + b_h)</math>,<br />
<br />
<math>y_t = \sigma_y(W_y h_t + b_y)</math>,<br />
<br />
=== Эхо-сети ===<br />
Эхо-сеть (англ. Echo State Network, ESN) характеризуется одним скрытым слоем (который называется резервуаром) со случайными редкими связями между нейронами. При этом связи внутри резервуара фиксированы, но связи с выходным слоем подлежат обучению. Состояние резервуара (state) вычисляется через предыдущие состояния резервуара, а также предыдущие состояния входного и выходного сигналов. Так как эхо-сети обладают только одним скрытым слоем, они обладают достаточно низкой вычислительной сложностью.<br />
<br />
=== Нейронный компрессор истории ===<br />
Нейронный компрессор исторических данных {{---}} это блок, позволяющий в сжатом виде хранить существенные исторические особенности процесса, который является своего рода стеком рекуррентной нейронной сети, формируемым в процессе самообучения.<br />
[[File:LSTM.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоев рекуррентной сети долго-краткосрочной памяти]]]<br />
<br />
=== Сети долго-краткосрочной памяти ===<br />
[[:Долгая_краткосрочная_память|Сеть долго-краткосрочной памяти]] (англ. Long short-term memory, LSTM) является самой популярной архитектурой рекуррентной нейронной сети на текущий момент, такая архитектура способна запоминать данные на долгое время.<ref name=LSTM>[https://www.bioinf.jku.at/publications/older/2604.pdf Sepp Hochreiter, Jurgen Schmidhuber. Long short-term memory (1997). Neural Computation.]</ref><br />
<br />
=== Управляемые рекуррентные блоки ===<br />
Управляемые рекуррентные блоки (англ. Gated Recurrent Units, GRU) {{---}} обладает меньшим количеством параметров, чем у LSTM, и в ней отсутствует выходное управление. При этом производительность в моделях речевого сигнала или полифонической музыки оказалась сопоставимой с LSTM.<br />
<br />
== Пример кода ==<br />
Пример кода на Python с использованием библиотеки Keras.<ref name=KerasRNN>[https://keras.io/layers/recurrent/ Keras RNN]</ref><br />
<br />
<font color="green"># Импорты</font><br />
'''import''' numpy '''as''' np<br />
'''from''' keras.preprocessing '''import''' sequence<br />
'''from''' keras.models '''import''' Sequential<br />
'''from''' keras.layers '''import''' Dense, Activation, Embedding<br />
'''from''' keras.layers '''import''' LSTM<br />
'''from''' keras.datasets '''import''' imdb<br />
<br />
<font color="green"># Устанавливаем seed для обеспечения повторяемости результатов</font><br />
np.random.seed(<font color="blue">42</font>)<br />
<br />
<font color="green"># Указываем количество слов из частотного словаря, которое будет использоваться (отсортированы по частоте использования)</font><br />
max_features = <font color="blue">5000</font><br />
<br />
<font color="green"># Загружаем данные (датасет IMDB содержит 25000 рецензий на фильмы с правильным ответом для обучения и 25000 рецензий на фильмы с правильным ответом для тестирования)</font><br />
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words = max_features)<br />
<br />
<font color="green"># Устанавливаем максимальную длину рецензий в словах, чтобы они все были одной длины</font><br />
maxlen = <font color="blue">80</font><br />
<br />
<font color="green"># Заполняем короткие рецензии пробелами, а длинные обрезаем</font><br />
X_train = sequence.pad_sequences(X_train, maxlen = maxlen)<br />
X_test = sequence.pad_sequences(X_test, maxlen = maxlen)<br />
<br />
<font color="green"># Создаем модель последовательной сети</font><br />
model = Sequential()<br />
<font color="green"># Добавляем слой для векторного представления слов (5000 слов, каждое представлено вектором из 32 чисел, отключаем входной сигнал с вероятностью 20% для предотвращения переобучения)</font><br />
model.add(Embedding(max_features, <font color="blue">32</font>, dropout = <font color="blue">0.2</font>))<br />
<font color="green"># Добавляем слой долго-краткосрочной памяти (100 элементов для долговременного хранения информации, отключаем входной сигнал с вероятностью 20%, отключаем рекуррентный сигнал с вероятностью 20%)</font><br />
model.add(LSTM(<font color="blue">100</font>, dropout_W = <font color="blue">0.2</font>, dropout_U = <font color="blue">0.2</font>))<br />
<font color="green"># Добавляем полносвязный слой из 1 элемента для классификации, в качестве функции активации будем использовать сигмоидальную функцию</font><br />
model.add(Dense(<font color="blue">1</font>, activation = <font color="red">'sigmoid'</font>))<br />
<br />
<font color="green"># Компилируем модель нейронной сети</font><br />
model.compile(loss = <font color="red">'binary_crossentropy'</font>,<br />
optimizer = <font color="red">'adam'</font>,<br />
metrics = [<font color="red">'accuracy'</font>])<br />
<br />
<font color="green"># Обучаем нейронную сеть (данные для обучения, ответы к данным для обучения, количество рецензий после анализа которого будут изменены веса, число эпох обучения, тестовые данные, показывать progress bar или нет)</font><br />
model.fit(X_train, y_train, <br />
batch_size = <font color="blue">64</font>,<br />
nb_epoch = <font color="blue">7</font>,<br />
validation_data = (X_test, y_test),<br />
verbose = <font color="blue">1</font>)<br />
<br />
<font color="green"># Проверяем качество обучения на тестовых данных (если есть данные, которые не участвовали в обучении, лучше использовать их, но в нашем случае таковых нет)</font><br />
scores = model.evaluate(X_test, y_test, batch_size = <font color="blue">64</font>)<br />
print(<font color="red">'Точность на тестовых данных: %.2f%%'</font> % (scores[1] * <font color="blue">100</font>))<br />
<br />
==См. также==<br />
*[[:Сверточные_нейронные_сети|Сверточные нейронные сети]]<br />
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]<br />
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]<sup>[на 28.01.19 не создан]</sup><br />
<br />
==Примечания==<br />
<references/><br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Нейронные сети]]<br />
[[Категория: Рекуррентные нейронные сети]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=Generative_Adversarial_Nets_(GAN)&diff=69683Generative Adversarial Nets (GAN)2019-01-30T20:29:22Z<p>Dariyakovleva: </p>
<hr />
<div>[[File:Арх_ган.png|450px|thumb|Оригинальная архитектура GAN]]<br />
<br />
'''Порождающие состязательные сети''' (англ. ''Generative Adversarial Nets, GAN'') {{---}} алгоритм машинного обучения, входящий в семейство [[:Порождающие модели|порождающих моделей]]<sup>[на 28.01.19 не создан]</sup> и построенный на комбинации из двух нейронных сетей, одна из которых генерирует образцы, другая пытается отличить настоящие образцы от сгенерированных. Впервые такие сети были представлены Иэном Гудфеллоу в 2014 году. <br />
<br />
==Постановка задачи и метод==<br />
Имеется множество образцов <tex>X</tex> из распределения <tex>p_{data}</tex>, заданного на <tex> \mathbb R^n </tex>, а также некоторое пространство латентных факторов <tex>Z</tex> из распределения <tex>p_{z}</tex>, например, случайные вектора из равномерного распределения <tex> \mathbb U^t(0,1) </tex>.<br />
<br />
Рассмотрим две нейронные сети: первая $-$ ''генератор'' <tex> G: Z \rightarrow \mathbb R^n </tex> с параметрами <tex>\theta</tex>, цель которой сгенерировать похожий образец из <tex>p_{data}</tex>, и вторая $-$ ''дискриминатор'' <tex>D: \mathbb R^n \rightarrow \mathbb [0,1] </tex> с параметрами <tex>\gamma</tex>, цель которой выдавать максимальную оценку на образцах из <tex>X</tex> и минимальную на сгенерированных образцах из <tex>G</tex>. Распределение, порождаемое генератором будем обозначать <tex>p_{gen}</tex>. Так же заметим, что в текущем изложении не принципиальны архитектуры нейронных сетей, поэтому можно считать, что параметры <tex>\theta</tex> и <tex>\gamma</tex> являются просто параметрами многослойных персептронов.<br />
<br />
В качестве примера можно рассматривать генерацию реалистичных фотографий: в этом случае, входом для генератора может быть случайный многомерный шум, а выходом генератора (и входом для дискриминатора) RGB-изображение; выходом же для дискриминатора будет вероятность, что фотография настоящая, т.е число от 0 до 1. <br />
<br />
Наша задача выучить распределение <tex>p_{gen}</tex> так, чтобы оно как можно лучше описывало <tex>p_{data}</tex>. Зададим функцию ошибки для получившейся модели. Со стороны дискриминатора мы хотим распознавать образцы из <tex>X</tex> как правильные, т.е в сторону единицы, и образцы из <tex>G</tex> как неправильные, т.е в сторону нуля, таким образом нужно максимизировать следующую величину:<br />
<br />
<center> <tex>\mathop{E}\limits_{x \sim p_{data}}[logD(x)] + \mathop{E}\limits_{x \sim p_{gen}}[log(1-D(x))]</tex>, где <tex>\mathop{E}\limits_{x \sim p_{gen}}[log(1-D(x))] = \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z))]</tex> </center>,<br />
<br />
Со стороны же генератора требуется научиться "обманывать" дискриминатор, т.е минимизировать по <tex>p_{gen}</tex> второе слагаемое предыдущего выражения. Другими словами, <tex>G</tex> и <tex>D</tex> играют в так называемую ''минимаксную игру'', решая следующую задачу оптимизации:<br />
<br />
<center> <tex> \min\limits_{G}\max\limits_{D} \mathop{E}\limits_{x \sim p_{data}}[logD(x)] + \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z))] </tex> </center>, <br />
<br />
Теоретическое обоснование того, что такой метод заставляет <tex>p_{gen}</tex> сходится к <tex>p_{data}</tex> описано в исходной статье. <ref> [https://arxiv.org/pdf/1406.2661.pdf Ian J. Goodfellow {{---}} Generative Adversarial Nets]</ref><br />
<br />
==Оригинальный алгоритм обучения GAN==<br />
[[File:Обучение_ган.png|450px|thumb|right|Визуализация генерирования фотографии с помощью DCGAN по одному и тому же шуму в зависимости от итерации обучения. Источник: https://arxiv.org/pdf/1701.07875.pdf]]<br />
<br />
В процессе обучения требуется делать два шага оптимизации поочередно: сначала обновлять веса генератора <tex>\theta</tex> при фиксированном <tex>\gamma</tex>, а затем веса дискриминатора <tex>\gamma</tex> при фиксированном <tex>\theta</tex>. На практике дискриминатор обновляется <tex>k</tex> раз вместо одного; <tex>k</tex> является гиперпараметром.<br />
<br />
<font color=green>// num_iteration {{---}} число итераций обучения </font><br />
'''function''' GAN:<br />
'''for''' i = 1..num_iteration '''do'''<br />
'''for''' j = 1..k '''do'''<br />
$z$ = getBatchFromNoisePrior($p_z$) <font color=green>//Получаем мини-батч $\{z_1, . . . , z_m\}$ из распределения $p_z$ </font><br />
$x$ = getBatchFromDataGeneratingDistibution($p_{data}$) <font color=green>//Получаем мини-батч $\{x_1, . . . , x_m\}$ из распределения $p_{data}$ </font> <br />
<tex>d_w \leftarrow \mathop{\nabla}_{\gamma} { \frac{1}{m} \sum_{t = 1}^m \limits} [logD(x_t)] + [log(1-D(G(z_t))] </tex> <font color=green>//Обновляем дискриминатор в сторону возрастания его градиента </font><br />
'''end''' '''for'''<br />
$z$ = getBatchFromNoisePrior($p_z$) <font color=green>//Получаем мини-батч $\{z_1, . . . , z_m\}$ из распределения $p_z$ </font><br />
<tex>g_w \leftarrow \mathop{\nabla}_{\theta} { \frac{1}{m} \sum_{t = 1}^m \limits} [log(1-D(G(z_t))] </tex> <font color=green>//Обновляем генератор в сторону убывания его градиента </font><br />
'''end''' '''for'''<br />
Обновления на основе градиента могут быть сделаны любым стандартным способом, например, в оригинальной статье использовался [[:Cтохастический градиентный спуск|стохастический градиентный спуск]]<sup>[на 28.01.19 не создан]</sup> с импульсом.<br />
<br />
==Улучшение обучения GAN==<br />
<br />
Большинство GAN'ов подвержено следующим проблемам:<br />
* Несходимость (non-convergence): параметры модели дестабилизируются и не сходятся;<br />
* Схлопывание мод распределения (mode collapse): генератор коллапсирует, т.е выдает ограниченное количество разных образцов;<br />
* Исчезающий градиент (diminished gradient): дискриминатор становится слишком "сильным", а градиент генератора исчезает и обучение не происходит;<br />
* Высокая чувствительность к гиперпараметрам.<br />
<br />
Универсального подхода к их решению нет, но существуют практические советы<ref> [https://github.com/soumith/ganhacks How to Train a GAN? Tips and tricks to make GANs work]</ref>, которые могут помочь. Основными из них являются:<br />
# Нормализация данных. Все признаки в диапазоне $[-1; 1]$;<br />
# Замена функции ошибки для $G$ с $\min log (1-D)$ на $\max log D$, потому что исходный вариант имеет маленький градиент на раннем этапе обучения и большой градиент при сходимости, а предложенный наоборот;<br />
# Сэмплирование из многомерного нормального распределения вместо равномерного; <br />
# Использовать нормализационные слои (например, batch normalization или layer normalization) в $G$ и $D$;<br />
# Использовать метки для данных, если они имеются, т.е обучать дискриминатор еще и классифицировать образцы.<br />
<br />
==Применение==<br />
<br />
[[File:прогресс_ганов.jpg|450px|thumb|right|Прогресс в генерации фотографий с помощью GAN. Источник: https://twitter.com/goodfellow_ian]]<br />
<br />
Чаще всего GAN'ы используются для генерации реалистичных фотографий. Серьезные улучшения в этом направлении были сделаны следующими работами:<br />
<br />
* Auxiliary GAN<ref> [https://arxiv.org/pdf/1610.09585.pdf Augustus Odena {{---}} Conditional Image Synthesis with Auxiliary Classifier GANs]</ref>: вариант GAN-архитектуры, использующий метки данных;<br />
* SN-GAN<ref> [https://arxiv.org/pdf/1802.05957.pdf Takeru Miyato {{---}} SPECTRAL NORMALIZATION FOR GENERATIVE ADVERSARIAL NETWORKS]</ref>: GAN с новым подходом решения проблемы нестабильного обучения через спектральную нормализацию;<br />
* SAGAN<ref> [https://arxiv.org/pdf/1805.08318.pdf Han Zhang {{---}} Self-Attention Generative Adversarial Networks]</ref>: GAN, основанный на механизме внимания;<br />
* BigGAN<ref> [https://arxiv.org/pdf/1809.11096.pdf Andrew Brock {{---}} LARGE SCALE GAN TRAINING FOR HIGH FIDELITY NATURAL IMAGE SYNTHESIS]</ref>: GAN с ортогональной регуляризацией, позволившей разрешить проблему коллапсирования при долгом обучении;<br />
<br />
Кроме простой генерации изображений, существуют достаточно необычные применения, дающие впечатляющие результаты не только на картинках, но и на звуке:<br />
<br />
* CycleGAN<ref> [https://junyanz.github.io/CycleGAN/ Jun-Yan Zhu & Taesung Park {{---}} Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks]</ref>: меняет изображения c одного домена на другой, например, лошадей на зебр;<br />
* SRGAN<ref> [https://arxiv.org/abs/1609.04802 Christian Ledig {{---}} Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network]</ref>: создает изображения с высоким разрешением из более низкого разрешения;<br />
* Pix2Pix<ref> [https://phillipi.github.io/pix2pix/ Phillip Isola {{---}} Image-to-Image Translation with Conditional Adversarial Nets]</ref>: создает изображения по семантической окраске;<br />
* StackGAN<ref> [https://arxiv.org/abs/1612.03242 Han Zhang {{---}} StackGAN: Text to Photo-realistic Image Synthesis with Stacked Generative Adversarial Networks]</ref>: создает изображения по заданному тексту;<br />
* MidiNet<ref> [https://arxiv.org/abs/1703.10847 Li-Chia Yang {{---}} MIDINET: A CONVOLUTIONAL GENERATIVE ADVERSARIAL NETWORK FOR SYMBOLIC-DOMAIN MUSIC GENERATION]</ref>: генерирует последовательность нот, таким образом, создает мелодию.<br />
<br />
==CGAN (Conditional Generative Adversarial Nets)==<br />
<br />
[[File:CGAN_architecture.png|450px|thumb|Архитектура CGAN. Источник: https://arxiv.org/pdf/1411.1784.pdf]]<br />
<br />
'''Условные порождающие состязательные сети''' (англ. ''Conditional Generative Adversarial Nets, CGAN'') $-$ это модифицированная версия алгоритма GAN, которая позволяет <br />
генерировать объекты с дополнительными условиями '''y'''. '''y''' может быть любой дополнительной информацией, например, меткой класса или данными из других моделей. Добавление данных условий в существующую архитектуру осуществляется с помощью расширения вектором '''y''' входных данных генератора и дискриминатора.<br />
<br />
В таком случае задача оптимизации будет выглядеть следующим образом:<br />
<br />
<center> <tex> \min\limits_{G}\max\limits_{D} \mathop{E}\limits_{x \sim p_{data}}[logD(x|y)] + \mathop{E}\limits_{z \sim p_{z}}[log(1-D(G(z|y))] </tex> </center><br />
<br />
В качестве примера использования данного алгоритма можно рассмотреть задачу генерации рукописных цифр. ''CGAN'' был натренирован на датасете ''MNIST'' с метками классов представленных в виде ''one-hot'' векторов.<br />
<br />
[[File:CGAN_generated.png|450px|thumb|Цифры, сгенерированные с помощью CGAN. Источник: https://arxiv.org/pdf/1411.1784.pdf]]<br />
<br />
==DCGAN (Deep Convolutional Generative Adversarial Nets)==<br />
<br />
[[File:DCGAN_generator.png|450px|thumb|Архитектура генератора в DCGAN. Источник: https://arxiv.org/pdf/1511.06434.pdf]]<br />
<br />
'''DCGAN''' $-$ модификация алгоритма ''GAN'', основными архитектурными изменениями которой являются:<br />
* Замена всех пулинговых слоев на страйдинговые свертки (''strided convolutions'') в дискриминаторе и частично-страйдинговые свертки (''fractional-strided''<br />
''convolutions'') в генераторе;<br />
* Использование батчинговой нормализации для генератора и дискриминатора;<br />
* Удаление всех полносвязных скрытых уровней для более глубоких архитектур;<br />
* Использование ''ReLU'' в качестве функции активации в генераторе для всех слоев, кроме последнего, где используется ''tanh'';<br />
* Использование ''LeakyReLU'' в качестве функции активации в дискриминаторе для всех слоев.<br />
<br />
Помимо задачи генерации объектов, данный алгоритм хорошо показывает себя в качестве ''feature extractor'''а.<br />
Данный алгоритм был натренирован на датасете ''Imagenet-1k'', после чего были использованы значения со сверточных слоев дискриминатора, подвергнутые ''max-pooling'''у, чтобы образовать матрицы <br />
<tex> 4 \times 4 </tex> и получить общий вектор признаков на их основе. ''L2-SVM'' с данным ''feature extractor'''ом на датасете ''CIFAR-10'' превосходит по точности решения, основанные на алгоритме<br />
''K-Means''. Более подробно об этом вы можете прочитать в статье. <ref> [https://arxiv.org/pdf/1511.06434.pdf Alec Radford, Luke Metz, Soumith Chintala {{---}} Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks]</ref><br />
<br />
<br />
==См. также==<br />
*[[:Порождающие модели|Порождающие модели]]<sup>[на 28.01.19 не создан]</sup><br />
*[[:Variational autoencoder (VAE)|Variational autoencoder (VAE)]]<sup>[на 28.01.19 не создан]</sup><br />
<br />
==Примечания==<br />
<references/><br />
== Источники информации ==<br />
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 348-360.<br />
* [https://medium.com/@jonathan_hui/gan-why-it-is-so-hard-to-train-generative-advisory-networks-819a86b3750b Medium | GAN — Why it is so hard to train Generative Adversarial Networks! ]<br />
* [https://arxiv.org/pdf/1411.1784.pdf CGAN Paper]<br />
* [https://arxiv.org/pdf/1511.06434.pdf DCGAN Paper]<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Порождающие модели]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%92%D0%B0%D1%80%D0%B8%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BA%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D1%89%D0%B8%D0%BA&diff=69682Вариационный автокодировщик2019-01-30T20:26:11Z<p>Dariyakovleva: </p>
<hr />
<div>'''Вариационный автокодировщик''' (англ. ''Variational Autoencoder'', ''VAE'') {{---}} [[автокодировщик]]<sup>[на 28.01.19 не создан]</sup> (генеративная модель, которая учится отображать объекты в заданное скрытое пространство (и обратно)) основанный на вариационном выводе.<br />
<br />
<br />
== Предпосылки ==<br />
При попытке использования обыкновенного автокодировщика для генерации новых объектов (желательно из того же априорного распределения, что и датасет) возникает следующая проблема. Случайной величиной с каким распределением проинициализировать скрытые векторы, для того, чтобы картинка, после применения декодера, стала похожа на картинки из датасета, но при этом не совпадала ни с одной из них? Ответ на этот вопрос не ясен, в связи с тем, что обыкновенный автокодировщик не может ничего утверждать про распределение скрытого вектора и даже про его область определения. В частности, область определения может быть даже дискретной.<br />
<br />
Вариационный автокодировщик в свою очередь предлагает пользователю самому определить распределение скрытого вектора. <br />
<br />
== Описание ==<br />
'''Порождающее моделирование''' (англ. ''Generative modelling'') {{---}} область машинного обучения, имеющая дело с распределением <math>P(X)</math>, определенном на датасете <math>X</math> из пространства (возможно многомерного) <math>X</math>. Так, например, популярные задачи генерации картинок имеют дело с огромным количеством измерений (пикселей). <br />
<br />
Также как и в обыкновенных кодировщиках у нас имеется скрытое вероятностное пространство <math>Z</math> соответствующее случайной величине <math>(z, P(z))</math> (распределенной как-нибудь фиксированно, здесь <math>\sim N(0, 1)</math>). И мы хотим иметь декодер <math>f(z, \theta) \colon Z \times \Theta \to X </math>. При этом мы хотим найти такие <math>\theta</math>, чтобы после разыгрывания <math>z</math> по <math>P(z)</math> мы получили "что-то похожее" на элементы <math>X</math>. <br />
<br />
Вообще, для любого <math>x \in X</math> мы хотим считать <math>P(x) = \int P(x|z; \theta)P(z)dz</math>, здесь мы заменили <math>f(z, \theta)</math> на <math>P(x|z; \theta)</math>, чтобы явно показать зависимость между <math>x</math> и <math>z</math> и после этого применить формулу полной вероятности. Обычно <math>P(x|z; \theta)</math> около нуля почти для всех пар <math>(x, z)</math>. Основная идея в том, что мы хотим теперь генерировать <math>z</math>, который бы давали что-то около <math>x</math> и только их суммировать в <math>P(x)</math>. Для этого нам требуется ввести еще одно распределение <math>Q(z|X)</math>, которое будет получать <math>x</math> и говорить распределение на <math>z</math> которое наиболее вероятно будет генерировать нам такой <math>x</math>. Теперь нам нужно как-то сделать похожими распределения <math>E_{z\sim Q}P(X|z)</math> и <math>P(X)</math>. <br />
<br />
Рассмотрим следующую дивергенцию Кульбака-Лейблера (''Kullback–Leibler divergence'', ''KL-div'').<br />
:<math>D[Q(z)||P(z|X)] = E_{z∼Q} [log Q(z|X) − log P(z|X)]</math>,<br />
<br />
Распишем <math>P(z|X)</math> как <math>P(X|z) * P(z) / P(X)</math>.<br />
:<math>D[Q(z)||P(z|X)] = E_{z∼Q} [log Q(z) − log P(X|z) - log P(z)] + log P(X)</math>,<br />
<br />
Что эквивалентно:<br />
:<math>logP(x) - D[Q(z)||P(z|X)] = E_{z∼Q}[log P(X|z)] - D[Q(z)||P(z)]</math>,<br />
<br />
Рассмотрим эту штуку для <math>Q(z|X)</math>, тогда:<br />
:<math>logP(x) - D[Q(z|X)||P(z|X)] = E_{z∼Q}[log P(X|z)] - D[Q(z|X)||P(z)]</math>,<br />
<br />
Посмотрим, на это равенство. Правую часть мы можем оптимизировать градиентным спуском (пусть пока и не совсем понятно как).<br />
В левой же части первое слагаемое {{---}} то, что мы хотим максимизировать. В то же время <math>D[Q(z|X)||P(z|X)]</math> мы хотим минимизировать. Если у нас <math>Q(z|X)</math> {{---}} достаточно сильная модель, то в какой-то момент она будет хорошо матчить <math>P(z|X)</math>, а значит их дивергенция Кульбака-Лейблера будет почти 0. Значит, при оптимизации можно исключить эту часть и стараться максимизировать только правую. В качестве бонуса мы еще получили более "податливую" <math>P(z|X)</math>, вместо нее можно смотреть на <math>Q(z|X)</math>.<br />
<br />
Теперь разберемся как оптимизировать правую часть. Сначала нужно определиться с моделью для <math>Q(z|X)</math>. Обычно ее берут равной <math>N(z|\mu(X, \theta), \sigma(X, \theta))</math>. Где <math>\mu</math> и <math>\sigma</math> какие-то детерминированные функции на X с обучаемыми параметрами <math>\theta</math>, которые мы впредь будем опускать (обычно используются нейронные сети). <br />
<br />
<br />
Нетрудно проверить, что для дивергенция Кульбака-Лейблера двух нормальных распределений имеет следующий вид:<br />
:<math>D_{K}[N(\mu_1, \Sigma_0)||N(\mu_1, \Sigma_0)]</math>, KLD есть <math>\frac{1}{2} (tr(\Sigma_1^{-1}\Sigma_0) + (\mu_1 - \mu_0)^T\Sigma_1^{-1}(\mu_1 - \mu_0) - k + log(\frac{det\Sigma_1}{det\Sigma_0})) </math>.<br />
<br />
Это значит, что<br />
:<math>D[Q(z|X)||P(z)] = D[N(\mu(X), \Sigma(X))||N(0, I)] = \frac12 (tr(\Sigma(X)) + \mu(X)^T\mu(X) - k - log(det\Sigma(X)))</math>. <br />
Теперь здесь <br />
можно считать градиенты, для BackPropagation. С первым слагаемым в правой части все немного сложнее. <math>E_{z∼Q}[log P(X|z)]</math> мы можем считать методом Монте-Карло(МК), но тогда такая штука (из-за того, что переменные спрятаны в распределении, из которого мы генерируем себе выборку, для МК) не является гладкой относительно них, а значит непонятно, как проталкивать через это градиент. Для того, чтобы все-таки можно было протолкнуть градиент, применяется так называемый ''трюк репараметризации'', который базируется на простой формуле <math>N(\Sigma(X), \mu(X)) = \mu(X) + \Sigma^{\frac12}(X) * N(0, I) </math>. <br />
<br />
:<math>E_{z∼Q}[log P(X|z)] = E_{\epsilon \sim N(0, I)}[log P(X = f(\mu(X) + \Sigma^{\frac12}(X) * \epsilon), \theta)]</math>. <br />
В такой форме мы уже можем использовать BackPropagation для переменных из функций <math>\Sigma</math> и <math>\mu</math>.<br />
<br />
Следующая картинка лучше поможет осознать структуру VAE и, в частности, зачем нужен (и как работает) трюк репараметризации.<br />
<br />
На левой части диаграмма без использования reparameterization trick. <br />
На правой части диаграмма с использованием reparameterization trick. <br />
<br />
[[Файл:VAE.PNG]]<br />
<br />
взято из https://arxiv.org/pdf/1606.05908.pdf<br />
<br />
== Пример реализации ==<br />
Ниже приведена реализация частного случая VAE на языке Python с использованием библиотеки Pytorch.<br />
Эта реализация работает с датасетом MNIST.<br />
Размерность скрытого слоя {{---}} 2. <br />
Координаты в нем считаются независимыми (из-за этого, например, матрица <math>\Sigma</math> диагональная, и формула для расчета KLD немного другая).<br />
<br />
class VariationalAutoencoder(nn.Module):<br />
def __init__(self):<br />
super().__init__()<br />
self.mu = nn.Linear(32, 2)<br />
self.gamma = nn.Linear(32, 2)<br />
self.encoder = nn.Sequential(nn.Linear(784, 32), nn.ReLU(True))<br />
self.decoder = nn.Sequential(nn.Linear(2, 32), nn.ReLU(True), nn.Linear(32, 784), nn.Sigmoid())<br />
<br />
def forward(self, x):<br />
mu, gamma = self.encode(x)<br />
encoding = self.reparameterize(mu, gamma)<br />
x = self.decoder(encoding)<br />
return x, mu, gamma<br />
<br />
def reparameterize(self, mu, gamma):<br />
if self.training:<br />
sigma = torch.exp(0.5*gamma)<br />
std_z = Variable(torch.from_numpy(np.random.normal(0, 1, size=sigma.size())).float())<br />
encoding = std_z.mul(sigma).add(mu)<br />
return encoding<br />
else:<br />
return mu<br />
<br />
def encode(self, x):<br />
x = self.encoder(x)<br />
mu = self.mu(x)<br />
gamma = self.gamma(x)<br />
return mu, gamma<br />
<br />
def decode(self, x):<br />
return self.decoder(x)<br />
<br />
def latent(self, x):<br />
mu, gamma = self.encode(x)<br />
encoding = self.reparameterize(mu, gamma)<br />
return encoding<br />
<br />
def loss_function(input, output, mu, gamma, batch_size=batch_size):<br />
BCE = F.binary_cross_entropy(output, input)<br />
KLD = -0.5*torch.sum(1 + gamma - mu.pow(2) - gamma.exp())<br />
KLD /= batch_size*784<br />
return BCE + KLD<br />
<br />
== Применение ==<br />
Область применения вариационных автокодировщиков совпадает с областью применения обыкновенных автокодировщиков. А именно:<br />
* Каскадное обучение глубоких сетей (хотя сейчас применяется все реже, в связи с появлением новых методов инициализации весов);<br />
* Уменьшение шума в данных;<br />
* Уменьшение размерности данных (иногда работает лучше, чем [[метод главных компонент]]<sup>[на 28.01.19 не создан]</sup>).<br />
<br />
Благодаря тому, что пользователь сам устанавливает нужное распределение скрытого вектора, вариационный кодировщик хорошо подходит для генерации новых объектов (например, картинок). Для этого достаточно разыграть скрытый вектор согласно его распределению и подать на вход декодера. Получится объект из того же распределения, что и датасет.<br />
<br />
== См. также ==<br />
*[[:Автокодировщик|Автокодировщик]]<sup>[на 28.01.19 не создан]</sup> <br />
*[[:Generative Adversarial Nets (GAN)|Порождающие состязательные сети]]<br />
<br />
== Примечания ==<br />
*[https://habr.com/ru/post/429276/ Вариационные автокодировщики: теория и рабочий код]<br />
*[https://jaan.io/what-is-variational-autoencoder-vae-tutorial/ Tutorial - What is a variational autoencoder?]<br />
*[https://towardsdatascience.com/intuitively-understanding-variational-autoencoders-1bfe67eb5daf Intuitively Understanding Variational Autoencoders]<br />
<br />
== Источники информации ==<br />
*[https://arxiv.org/abs/1606.05908 Tutorial on Variational Autoencoders]<br />
*Datalore презентация Дениса Степанова<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Порождающие модели]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D0%B5%D1%81%D1%82%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE_%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0&diff=69681Обработка естественного языка2019-01-30T20:23:59Z<p>Dariyakovleva: </p>
<hr />
<div>'''Обработка естественного языка''' (''Natural Language Processing, NLP'') {{---}} пересечение [[Машинное обучение | машинного обучения]] и математической лингвистики<ref>[https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80%D0%BD%D0%B0%D1%8F_%D0%BB%D0%B8%D0%BD%D0%B3%D0%B2%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%B0 Математическая лингвистика]</ref>, направленное на изучение методов анализа и синтеза естественного языка. Сегодня NLP применяется во многих сферах, в том числе в голосовых помощниках, автоматических переводах текста и фильтрации текста. Основными тремя направлениями являются: [[Распознавание речи | распознавание речи]] (Speech Recognition), понимание естественного языка (Natural Language Understanding<ref>[https://en.wikipedia.org/wiki/Natural-language_understanding Natural Language Understanding]</ref> ) и генерация естественного языка (Natural Language Generation<ref>[https://en.wikipedia.org/wiki/Natural-language_generation Natural Language Generation]</ref>).<br />
== Задачи ==<br />
{{Определение <br />
|definition=<br />
'''Корпус''' {{---}} подобранная и обработанная по определённым правилам совокупность текстов, используемых в качестве базы для исследования языка.<br />
}}<br />
NLP решает большой набор задач, который можно разбить по уровням (в скобках). Среди этих задач, можно выделить следующие:<br />
* Распознавание текста, речи, синтез речи (сигнал);<br />
* Морфологический анализ, канонизация (слово);<br />
* POS-тэгирование, распознавание именованных сущностей, выделение слов (словосочетание);<br />
* Синтаксический разбор, токенизация предложений (предложение);<br />
* Извлечение отношений, определение языка, анализ эмоциональной окраски (абзац);<br />
* Аннотация документа, перевод, анализ тематики (документ);<br />
* Дедубликация, информационный поиск (корпус).<br />
<br />
== Основные подходы ==<br />
=== Предобработка текста ===<br />
Предобработка текста переводит текст на естественном языке в формат удобный для дальнейшей работы. Предобработка состоит из различных этапов, которые могут отличаться в зависимости от задачи и реализации. Далее приведен один из возможных набор этапов:<br />
* Перевод всех букв в тексте в нижний или верхний регистры;<br />
* Удаление цифр (чисел) или замена на текстовый эквивалент (обычно используются регулярные выражения);<br />
* Удаление пунктуации. Обычно реализуется как удаление из текста символов из заранее заданного набора;<br />
* Удаление пробельных символов (whitespaces);<br />
* Токенизация (обычно реализуется на основе регулярных выражений);<br />
* Удаление стоп слов;<br />
* Стемминг;<br />
* Лемматизация;<br />
* Векторизация.<br />
<br />
=== Стемминг ===<br />
Количество корректных словоформ, значения которых схожи, но написания отличаются суффиксами, приставками, окончаниями и прочим, очень велико, что усложняет создание словарей и дальнейшую обработку. Стемминг позволяет привести слово к его основной форме. Суть подхода в нахождении основы слова, для этого с конца и начала слова последовательно отрезаются его части. Правила отсекания для стеммера создаются заранее, и чаще всего представляют из себя регулярные выражения, что делает данный подход трудоемким, так как при подключении очередного языка нужны новые лингвистические исследования. Вторым недостатком подхода является возможная потеря информации при отрезании частей, например, мы можем потерять информацию о части речи. <br />
<br />
=== Лемматизация ===<br />
Данный подход является альтернативой стемминга. Основная идея в приведении слова к словарной форме {{---}} лемме. Например для русского языка:<br />
* для существительных — именительный падеж, единственное число;<br />
* для прилагательных — именительный падеж, единственное число, мужской род;<br />
* для глаголов, причастий, деепричастий {{---}} глагол в инфинитиве несовершенного вида.<br />
<br />
=== Векторизация ===<br />
Большинство математических моделей работают в векторных пространствах больших размерностей, поэтому необходимо отобразить текст в векторном пространстве. Основным походом является мешок слов (bag-of-words): для документа формируется вектор размерности словаря, для каждого слова выделяется своя размерность, для документа записывается признак насколько часто слово встречается в нем, получаем вектор. Наиболее распространенным методом для вычисления признака является TF-IDF<ref>[https://ru.wikipedia.org/wiki/TF-IDF TF-IDF]</ref> (TF {{---}} частота слова, term frequency, IDF {{---}} обратная частота документа, inverse document frequency). TF вычисляется, например, счетчиком вхождения слова. IDF обычно вычисляют как логарифм от числа документов в корпусе, разделённый на количество документов, где это слово представлено. Таким образом, если какое-то слово встретилось во всех документах корпуса, то такое слово не будет никуда добавлено. Плюсами мешка слов является простая реализация, однако данный метод теряет часть информации, например, порядок слов. <br />
Для уменьшения потери информации можно использовать мешок N-грамм (добавлять не только слова, но и словосочетания), или использовать методы векторных представлений слов это, например, позволяет снизить ошибку на словах с одинаковыми написаниями, но разными значениями.<br />
<br />
=== Дедубликация ===<br />
Так как количество схожих документов в большом корпусе может быть велико, необходимо избавляться от дубликатов. Так как каждый документ может быть представлен как вектор, то мы можем определить их близость, взяв косинус или другую метрику. Минусом является то, что для больших корпусов полный перебор по всем документам будет невозможен. Для оптимизации можно использовать локально-чувствительный хеш, который поместит близко похожие объекты.<br />
<br />
=== Семантический анализ ===<br />
Семантический (смысловой) анализ текста {{---}} выделение семантических отношений, формировании семантического представления. В общем случае семантическое представление является графом, семантической сетью, отражающим бинарные отношения между двумя узлами — смысловыми единицами текста. Глубина семантического анализа может быть разной, а в реальных системах чаще всего строится только лишь синтаксико-семантическое представление текста или отдельных предложений.<br />
Семантический анализ применяется в задачах анализа тональности текста<ref>[https://en.wikipedia.org/wiki/Sentiment_analysis Анализ тональности текста]</ref>(Sentiment analysis), например, для автоматизированного определения положительности отзывов.<br />
<br />
=== Распознование именованных сущностей и извлечение отношений ===<br />
Именованные сущности {{---}} объекты из текста, которые могут быть отнесены к одной из заранее заявленных категорий (например, организации, личности, адреса). Идентификация ссылок на подобные сущности в тексте является задачей распознавания именованных сущностей.<br />
Станкевич Андрей Сергеевич {{---}} лауреат специальной премии корпорации IBM.<br />
'''Станкевич Андрей Сергеевич'''[личность] {{---}} лауреат специальной премии корпорации '''IBM'''[компания].<br />
Определение семантических отношений между именованными сущностями или другими объектами текста, является задачей извлечения отношений. Примеры отношений: (автор,книга), (организация,главный_офис).<br />
<br />
Эти два подхода применяются во многих задачах, например, извлечение синонимов из текста, автоматическом построении онтологий и реализованы во многих работающих системах, например, NELL<ref>[http://rtw.ml.cmu.edu/rtw/ NELL]</ref> и Snowball<ref>[http://www.mathcs.emory.edu/~eugene/papers/dl00.pdf Snowball]</ref>.<br />
<br />
=== Использование N-грамм ===<br />
{{Определение <br />
|definition=<br />
'''N-грамма''' {{---}} последовательность из <tex>n</tex> элементов.<br />
}}<br />
В NLP N-граммы используются для построения вероятностных моделей, задач схожести текстов, категоризации текста и языка. <br />
<br />
Построив N-граммную модель можно определить вероятность употребления заданной фразы в тексте. N-граммная модель рассчитывает вероятность последнего слова N-граммы, если известны все предыдущие, при этом полагается, что вероятность появления каждого слова зависит только от предыдущих слов.<br />
<br />
Использование N-грамм применяется в задаче выявления плагиата. Текст разбивается на несколько фрагментов, представленных N-граммами. Сравнение N-грамм друг с другом позволяет определить степень сходства документов. Аналогичным способом можно решать задачу исправления орфографических ошибок, подбирая слова кандидаты для замены.<br />
<br />
== Библиотеки для NLP ==<br />
=== NLTK (Natural Language ToolKit)<ref>[https://www.nltk.org/ NLTK]</ref> ===<br />
Пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на Python. Содержит графические представления и примеры данных. Поддерживает работу с множеством языков, в том числе, русским.<br />
<br />
Плюсы:<br />
* Самая известная и полная по функционалу библиотека для NLP;<br />
* Большое количество сторонних расширений;<br />
* Быстрая токенизация предложений;<br />
* Поддерживается множество языков.<br />
Минусы<br />
* Медленная;<br />
* Сложная в изучении и использовании;<br />
* Работает со строками;<br />
* Не использует нейронные сети;<br />
* Нет встроенных векторов слов.<br />
<br />
=== spaCy<ref>[https://spacy.io/ spaCy]</ref> ===<br />
Библиотека, написанная на языке Cypthon, позиционируется как самая быстрая NLP библиотека. Имеет множество возможностей, в том числе, разбор зависимостей на основе меток, распознавание именованных сущностей, пометка частей речи, векторы расстановки слов. Не поддерживает русский язык.<br />
<br />
Плюсы:<br />
* Самая быстрая библиотека для NLP;<br />
* Простая в изучении и использовании;<br />
* Работает с объектами, а не строками;<br />
* Есть встроенные вектора слов;<br />
* Использует нейронные сети для тренировки моделей.<br />
Минусы<br />
* Менее гибкая по сравнению с NLTK;<br />
* Токенизация предложений медленнее, чем в NLTK;<br />
* Поддерживает маленькое количество языков.<br />
<br />
=== scikit-learn<ref>[https://scikit-learn.org scikit-learn]</ref> ===<br />
Библиотека scikit-learn предоставляет реализацию целого ряда алгоритмов для обучения с учителем и обучения без учителя через интерфейс для Python. Построена поверх SciPy. Ориентирована в первую очередь на моделирование данных, имеет достаточно функций, чтобы использоваться для NLP в связке с другими библиотеками.<br />
<br />
Плюсы:<br />
* Большое количество алгоритмов для построения моделей;<br />
* Содержит функции для работы с Bag-of-Words моделью;<br />
* Хорошая документация.<br />
Минусы<br />
* Плохой препроцессинг, что вынуждает использовать ее в связке с другой библиотекой (например, NLTK);<br />
* Не использует нейронные сети для препроцессинга текста.<br />
<br />
=== gensim<ref>[https://radimrehurek.com/gensim/ gensim]</ref> ===<br />
Python библиотека для моделирования, тематического моделирования документов и извлечения подобия для больших корпусов. В gensim реализованы популярные NLP алгоритмы, например, word2vec. Большинство реализаций могут использовать несколько ядер.<br />
<br />
Плюсы:<br />
* Работает с большими датасетами;<br />
* Поддерживает глубокое обучение;<br />
* word2vec, tf-idf vectorization, document2vec.<br />
Минусы<br />
* Заточена под модели без учителя;<br />
* Не содержит достаточного функционала, необходимого для NLP, что вынуждает использовать ее вместе с другими библиотеками.<br />
<br />
<br />
<br />
Балто-славянские языки имеют сложную морфологию, что может ухудшить качество обработки текста, а также ограничить использование ряда библиотек. Для работы со специфичной русской морфологией можно использовать, например, морфологический анализатор '''pymorphy2'''<ref>[https://github.com/kmike/pymorphy2 pymorphy2]</ref> и библиотеку для поиска и извлечения именованных сущностей '''Natasha'''<ref>[https://github.com/natasha/natasha Natasha]</ref><br />
<br />
== Примеры использования NLTK ==<br />
* Разбиение на предложения:<br />
text = "Предложение. Предложение, которое содержит запятую. Восклицательный знак! Вопрос?" <br />
sents = nltk.sent_tokenize(text)<br />
print(sents)<br />
'''output:''' ['Предложение.', 'Предложение, которое содержит запятую.', 'Восклицательный знак!', 'Вопрос?']<br />
* Токенизация:<br />
from nltk.tokenize import RegexpTokenizer<br />
sent = "В этом предложении есть много слов, мы их разделим."<br />
tokenizer = RegexpTokenizer(r'\w+')<br />
print(tokenizer.tokenize(sent))<br />
'''output:''' ['В', 'этом', 'предложении', 'есть', 'много', 'слов', 'мы', 'их', 'разделим']<br />
<br />
from nltk import word_tokenize<br />
sent = "В этом предложении есть много слов, мы их разделим."<br />
print(word_tokenize(sent))<br />
'''output:''' ['В', 'этом', 'предложении', 'есть', 'много', 'слов', ',', 'мы', 'их', 'разделим', '.']<br />
* Стоп слова:<br />
from nltk.corpus import stopwords<br />
stop_words=set(stopwords.words('english'))<br />
print(stop_words)<br />
'''output:''' {'should', 'wouldn', 'do', 'over', 'her', 'what', 'aren', 'once', 'same', 'this', 'needn', 'other', 'been', 'with', 'all' ...<br />
<br />
* Стемминг и лемматизация:<br />
from nltk.stem.porter import PorterStemmer<br />
porter_stemmer = PorterStemmer()<br />
print(porter_stemmer.stem("crying"))<br />
'''output:''' cri<br />
<br />
from nltk.stem.lancaster import LancasterStemmer<br />
lancaster_stemmer = LancasterStemmer()<br />
print(lancaster_stemmer.stem("crying"))<br />
'''output:''' cry<br />
<br />
from nltk.stem import SnowballStemmer<br />
snowball_stemmer = SnowballStemmer("english")<br />
print(snowball_stemmer.stem("crying")) <br />
'''output:''' cri<br />
<br />
from nltk.stem import WordNetLemmatizer<br />
wordnet_lemmatizer = WordNetLemmatizer()<br />
print(wordnet_lemmatizer.lemmatize("came", pos="v"))<br />
'''output:''' come<br />
<br />
== Пример кода на языке Scala ==<br />
[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/nlp/TrainViveknSentiment.scala Пример реализации алгоримтма NLP] на основе Apache Spark ML<ref>[https://spark.apache.org/docs/latest/ml-guide.html Apache Spark MLlib]</ref>.<br />
<br />
==См. также==<br />
* [[Распознавание речи]]<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
==Источники информации==<br />
# [https://en.wikipedia.org/wiki/Natural_language_processing] {{---}} статья на Википедии<br />
# [http://www.nltk.org/book/ Natural Language Processing with Python] {{---}} Analyzing Text with the Natural Language Toolkit<br />
# [http://www.cs.colorado.edu/~martin/slp2.html Speech and Language Processing]<br />
[[Категория: Машинное обучение]] [[Категория: Обработка естественного языка]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0_%D0%B3%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=69680Настройка глубокой сети2019-01-30T20:20:52Z<p>Dariyakovleva: </p>
<hr />
<div>[[Глубокое обучение|Глубокая сеть]] состоит из нескольких слоев, где каждый слой организован таким образом, что каждый нейрон в одном слое получает свою копию всех выходных данных предыдущего слоя. Эта модель идеально подходит для определенных типов задач, например, обучение на ограниченном количестве более или менее неструктурированных параметров. Существует множество способов изменения параметров (весов) в такой модели, когда ей на вход поступают необработанные данные. <br />
<br />
== Инициализация сети ==<br />
<br />
Принцип выбора начальных значений весов для слоев, составляющих модель очень важен: установка всех весов в 0 будет серьезным препятствием для обучения, так как ни один из весов изначально не будет активен. Присваивать весам значения из интервала <tex>[-1, 1]</tex> — тоже обычно не лучший вариант — на самом деле, иногда (в зависимости от задачи и сложности модели) от правильной инициализации модели может зависеть, достигнет она высочайшей производительности или вообще не будет сходиться. Даже если задача не предполагает такой крайности, удачно выбранный способ инициализации весов может значительно влиять на способность модели к обучению, так как он предустанавливает параметры модели с учетом функции потерь<ref>[https://habr.com/company/wunderfund/blog/315476/ Тонкая настройка нейронной сети, Habr]</ref>.<br />
<br />
Всегда можно выбрать случайно начальное приближение, но лучше выбирать определённым образом, ниже приведены самые распространённые из них:<br />
<br />
* Метод инициализации Завьера (Xavier) (иногда — метод Glorot’а)<ref>[http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf Understanding the difficulty of training deep feedforward neural networks]</ref>. Основная идея этого метода — упростить прохождение сигнала через слой во время как прямого, так и обратного распространения ошибки для линейной функции активации (этот метод также хорошо работает для сигмоидной функции, так как участок, где она ненасыщена, также имеет линейный характер). При вычислении весов этот метод опирается на вероятностное распределение (равномерное или нормальное) с дисперсией, равной <tex>\mathrm{Var}(W) = {2 \over{n_{in} + n_{out}}}</tex>, где <tex>n_{in}</tex> и <tex>n_{out}</tex> — количества нейронов в предыдущем и последующем слоях соответственно;<br />
<br />
* Метод инициализации Ге (He) — вариация метода Завьера, больше подходящая функции активации ReLU, компенсирующая тот факт, что эта функция возвращает нуль для половины области определения. А именно, в этом случае <tex>\mathrm{Var}(W) = {2 \over{n_{in}}}</tex><ref>[https://arxiv.org/pdf/1502.01852.pdf Delving Deep into Rectifiers]</ref>.<br />
<br />
== Граф вычислений ==<br />
Глубокие сети являются особенной формой графа вычиcлений.<br />
[[Файл: tree-def.png|450px|thumb|Рис.1. Граф вычислений для функции <tex>f(a,b)=(a+b)*(b+1)</tex>]]<br />
Граф вычислений — ориентированный граф, узлы которого соответствуют операциям или переменным. Переменные могут передавать свое значение в операции, а операции могут передавать свои результаты в другие операции. Таким образом, каждый узел в графе определяет функцию переменных.<br />
<br />
Значения, которые вводятся в узлы и выходят из узлов, называются тензорами (т.е. многомерными массивами). На рисунке 1 представлен граф вычислений для функции <tex>f(a,b)=(a+b)*(b+1)</tex>. В нейронах сетях функций имеют больше аргументов и сложнее, но смысл операций остаётся прежним.<br />
<br />
Процесс передачи значений от входных нейронов к выходным называется прямым распространением (от англ. Forward pass). После чего мы вычисляем ошибку обработанных сетью данных на выходном нейроне и, основываясь на её значении, делаем обратную передачу ошибки ([[Обратное распространение ошибки|Back propagation]]). Обратное распространение ошибки заключается в том, чтобы последовательно менять веса нейронной сети, начиная с весов выходного нейрона. Значения весов будут меняться в сторону уменьшения ошибки.<br />
<br />
[[Файл: C_graph.png|400px|thumb|Рис.2. Граф вычислений для функции <tex>f(x,y,z)=(x+y)*z</tex>. Зелёные цифры — значения вычислений по ходу выполнения операций графа, красные — значения производной выходной функции по текущей переменной в точке <tex>(x_0=-2, y_0=5, z_0=-4)</tex>]] <br />
<br />
<br />
Преимуществом такого представления функции является простота вычисления производных. Используя следующие правила вычисления частных производных: <br />
*<tex>q=x+y:\frac{\partial q}{\partial x}=1, \frac{\partial q}{\partial y}=1;</tex>;<br />
*<tex>q=xy:\frac{\partial q}{\partial x}=y, \frac{\partial q}{\partial y}=x;</tex>;<br />
*<tex>\frac{\partial f}{\partial x}=\frac{\partial f}{\partial q}\frac{\partial q}{\partial y}</tex>. <br />
<br />
Рассмотрим граф вычислений на рисунке 2 с поданными на вход значениями <tex>(x_0=-2, y_0=5, z_0=-4)</tex>. Подсчёт производных по графу вычислений производим от значения функции к значениям независимых переменных-входов.<br />
<br />
* <tex>\frac{\partial f}{\partial f} = 1</tex>;<br />
* <tex>\frac{\partial f}{\partial q} = z_0 = -4</tex>, <tex>\frac{\partial f}{\partial z} = q_0 = 3</tex>;<br />
* <tex>\frac{\partial f}{\partial x} = \frac{\partial f}{\partial q}\frac{\partial q}{\partial x} = -4</tex>, <tex>\frac{\partial f}{\partial y} = \frac{\partial f}{\partial q}\frac{\partial q}{\partial y} = -4</tex>.<br />
<br />
<br />
Граф вычислений является частью нейронной сети, у которой <tex>x_{n_{in}}</tex> {{---}} входные значения, <tex>y_{n_{out}}</tex> {{---}} выходные с сети значения, <tex>w</tex> {{---}} матрица весов, приводящая значения предыдущего слоя к выходным значениям.<br />
<br />
Зная производные, можно искать матрицы весов <tex>w</tex> (числа, на которые умножаются входные для этого слоя значения) с помощью [[Настройка глубокой сети#Способы настройки параметров|градиентного спуска]] сдвигаемся<br />
в сторону градиента (при максимизации) или обратную ему<br />
(при минимизации) <tex>w^{(k+1)}=w^{(k)}-\eta \frac{\partial L(w^{(k)})}{\partial w^{(k)}}</tex>, где <tex>L</tex> — функция потерь, а <tex>w^{(k)}</tex> — веса после <tex>k</tex>-ой итерации, или его модификаций<ref>[http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D1%81%D0%BF%D1%83%D1%81%D0%BA%D0%B0 Метод градиентного спуска]</ref>.<br />
<br />
== Способы настройки параметров ==<br />
[[File:basins.png|450px|thumb|right|Рис.3. Сравение мотификаций метода градиентного спуска на ландшафте "бассейны и стены"<ref>[https://habr.com/post/318970/ Методы оптимизации нейронных сетей, Habr]</ref>.]]<br />
[[File:wolby.png|450px|thumb|right|Рис.4. Сравение мотификаций метода градиентного спуска на "шатком" ландшафте<ref>[https://habr.com/post/318970/ Методы оптимизации нейронных сетей, Habr]</ref>.]]<br />
Ниже представлены различные вариации градиентного спуска (более подробное сравнение, применительно к данной задаче <ref>[https://habr.com/post/318970/ Методы оптимизации нейронных сетей, Habr]</ref>). Градиентный спуск — итеративный алгоритм поиска минимума или максимума функции, метриками качества алгоритма этого семейства методов являются скорость сходимости и сходимость в глобальный оптимум. Методы имеют различные преимущества на различных функциях. Так например на рисунке 3 из локального минимума метод adam и метод Нестерова не могут достигнуть глобального, а в случае "шаткого" ландшафта (рисунок 4) эти методы сходятся быстрее.<br />
<br />
* [[Стохастический градиентный спуск|Метод стохастического градиентного спуска]] заключается в том, что алгоритм делает шаг постоянной величины в направлении, указанном градиентом в текущей точке: <tex>w^{(k+1)}=w^{(k)}-\mu\frac{\partial L(w^{(k)})}{\partial w^{(k)}}</tex>;<br />
<br />
<br />
* Модификация Momentum <ref>[https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Momentum Momentum, Wikipedia]</ref> запоминает скорость на предыдущем шаге и добавляет в <tex>\alpha</tex> раз меньшую величину на следующем шаге: <tex> v^{(k+1)}=\alpha v^{(k)} -\eta \frac{\partial L(w^{(k)})}{\partial w^{(k)}}</tex>, <tex> w^{(k+1)}=w^{(k)}+v^{(k)}</tex>;<br />
<br />
<br />
* Метод Нестерова (англ. Nesterov accelerated gradient, NAG)<ref>[https://jlmelville.github.io/mize/nesterov.html#nag Nesterov accelerated gradient]</ref> добавляет к методу Momentum идею "заглядывания вперёд", используя производную не в текущей точке, а в следующей (если бы мы продолжали двигаться в этом же направлении без измений): <tex> w^{(k+1)} = w^{(k)}-v^{(k)}; v^{(k+1)}=\gamma v^{(k)}+\mu\frac{\partial L(w^{(k)}-v^{(k)})}{\partial w}</tex>;<br />
<br />
<br />
*Adagrad имеет преимущество в плане обучения нейронных сетей в предположении, что процесс обучения должен сходится (т.е. не нужно сильно менять веса сети, когда мы уже немного научились). В процессе обучения после каждого прецендента алгоритм будет уменьшать шаг за счёт суммы квадратов координат градиента предыдущих итераций<ref>[http://akyrillidis.github.io/notes/AdaGrad AdaGrad]</ref>: <tex>g_i^{(k)}=\frac{\partial L(w_i^{(k)})}{\partial w_i^{(k)}}, w_i^{(k+1)}=w_i^{(k)}-\frac{\mu}{\sqrt{G^{(k)}_{i,i}+\epsilon}}g_{i}^{(k)}</tex>, где <tex>G</tex> — диагональная матрица, элементы которой, суммы квадратов координат градиента к <tex>k</tex>-ой итерации алгоритма: <tex>G_{i,i}^{(k)} = \sum_{t=0}^k (g_i^{(t)})^2</tex>;<br />
<br />
<br />
*RMSProp<ref>[https://towardsdatascience.com/a-look-at-gradient-descent-and-rmsprop-optimizers-f77d483ef08b RMSProp]</ref> основан на идее Adagrad'a, но с учётом того элементы матрицы <tex>G</tex> могут быть большими величинами и начать препятствовать обучению. Для этого RMSProp делит шаг не на полную сумму градиентов, а на скользящую, т.е. <tex>E_i^{(k)} = \gamma E_i^{(k-1)}+(1-\gamma)(g_{i}^{(k)})^2</tex>, обновление весов осталось таким же как в Adagrad : <tex> w_i^{(k+1)} = w_i^{(k)}-\frac{\mu}{\sqrt{E_i^{(k)}+\epsilon}}g_{i}^{(k)}</tex>;<br />
<br />
<br />
*Adadelta<ref>[https://arxiv.org/abs/1212.5701 Adadelta]</ref> устраняет "нефизичность" методов Adagrad и RMSProp, добавка с градиентом в которых не имеет размерности весов(точнее вообще безразмерна). Умножение этого слагаемого на любую величину правильной размерности — не самая хорошая идея. Используем разложение ряда Тейлора в точке с большим числом членов, тогда появится матрица <tex>Q</tex> вторых производных функции потерь: <tex>w^{(k+1)}=w^{(k)}-\mu(Q(w^{(k)})^{-1}Q(w^{(k)}))</tex>, рассчёт которой повлечёт за собой дополнительные затраты на её расчёт (сами градиенты мы получаем сразу при обратном распространии ошибки), поэтому вместо неё можно брать приближение (из сложных выводов получаем необходимиый множитель <tex>RMS^{(k-1)}[\delta w_i]</tex>), однако в данном случае знание предыдущей скорости не добавляет алгоритму "инерции" методов Momentum и NAG): <tex>w^{(k+1)}=w^{(k)}-\frac{RMS^{(k-1)}[\delta w_i]}{RMS^{(k)}[g_i]}g_i^{(k)}</tex>, где <tex>RMS^{(k)}[x_i]=\sqrt{E^{(k)}[x^2_i]+\epsilon}</tex>;<br />
<br />
<br />
*Adam<ref>[https://arxiv.org/pdf/1412.6980.pdf Adam]</ref> сочетает в себе преимущества NAG и Adadelta над обычным градиентным спуском: <tex> w^{(k+1)}_i = w_i^{(k)}-\frac{\mu}{\sqrt{\hat{b}^2_{(k)}+\epsilon}}\hat{m}_{(k)}</tex>, где <tex>\hat{m}_{(k)}=\frac{\gamma_1 E^{(k-1)}[g_i]+(1-\gamma_1)g_{i,(k)}}{1-\gamma_1^k}</tex> и <tex>\hat{b}^2_{(k)}= \frac{\gamma_2 E^{(k-1)}[g^2_i]+(1-\gamma_2)g:2_{i,(k)}}{1-\gamma_2^k}</tex>.<br />
<br />
==См.также==<br />
* [[Глубокое обучение]]<br />
* [[Стохастический градиентный спуск]]<br />
* [[Обратное распространение ошибки]]<sup>[на 28.01.19 страница не создана]</sup><br />
<br />
==Примечания==<br />
<references/><br />
<br />
==Источники информации==<br />
<br />
#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%28%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2%29 Курс лекций по машинному обучению] {{---}} Воронцов К.В.<br />
# Riedmiller, M., & Braun, H. (1993). A direct adaptive method for faster backpropagation learning: The RPROP algorithm. In Neural Networks, 1993., IEEE International Conference on (pp. 586-591). IEEE.<br />
<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Глубокое обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=Batch-normalization&diff=69679Batch-normalization2019-01-30T20:18:30Z<p>Dariyakovleva: </p>
<hr />
<div>'''Пакетная нормализация''' (англ. batch-normalization) {{---}} метод, который позволяет повысить производительность и стабилизировать работу [[Нейронные сети, перцептрон | искусственных нейронных сетей]]. Суть данного метода заключается в том, что некоторым слоям нейронной сети на вход подаются данные, предварительно обработанные и имеющие нулевое [[Математическое ожидание случайной величины|математическое ожидание]] и единичную [[Дисперсия случайной величины|дисперсию]]. Впервые данный метод был представлен в <ref>[https://arxiv.org/pdf/1502.03167.pdf Ioffe S., Szegedy C. {{---}} Batch normalization: Accelerating deep network training by reducing internal covariate shift, 2016]</ref>.<br />
<br />
==Идея==<br />
Нормализация входного слоя нейронной сети обычно выполняется путем масштабирования данных, подаваемых в функции активации. Например, когда есть признаки со значениями от <tex>0</tex> до <tex>1</tex> и некоторые признаки со значениями от <tex>1</tex> до <tex>1000</tex>, то их необходимо нормализовать, чтобы ускорить обучение. Нормализацию данных можно выполнить и в скрытых слоях нейронных сетей, что и делает метод пакетной нормализации.<br />
===Пакет===<br />
Предварительно, напомним, что такое '''пакет''' (англ. batch). Возможны два подхода к реализации алгоритма градиентного спуска для обучения нейросетевых моделей: стохастический и пакетный<ref>[http://www.machinelearning.ru/wiki/index.php?title=Метод_стохастического_градиента Метод стохастического градиента]</ref>. <br />
* [[Стохастический градиентный спуск|Стохастический градиентный спуск]] (англ. stochastic gradient descent) {{---}} реализация, в которой на каждой итерации алгоритма из обучающей выборки каким-то (случайным) образом выбирается только один объект; <br />
* Пакетный (батч) (англ. batch gradient descent) {{---}} реализация градиентного спуска, когда на каждой итерации обучающая выборка просматривается целиком, и только после этого изменяются веса модели. <br />
<br />
Также существует "золотая середина" между стохастическим градиентным спуском и пакетным градиентным спуском {{---}} когда просматривается только некоторое подмножество обучающей выборки фиксированного размера (англ. batch-size). В таком случае такие подмножества принято называть мини-пакетом (англ. mini-batch). Здесь и далее, мини-пакеты будем также называть пакетом.<br />
<br />
===Ковариантный сдвиг===<br />
[[Файл:covariate-shift1.png|600px|thumb|Рисунок 1. Верхние две строки роз показывают первое подмножество данных, а нижние две строки показывают другое подмножество. Два подмножества имеют разные пропорции изображения роз. На графиках показано распределение двух классов в пространстве объектов с использованием красных и зеленых точек. Синяя линия показывает границу между двумя классами. Иллюстрация из [https://www.learnopencv.com/batch-normalization-in-deep-networks/ статьи].]]<br />
Пакетная нормализация уменьшает величину, на которую смещаются значения узлов в скрытых слоях (т.н. '''[[Ковариация случайных величин|ковариантный]] сдвиг''' (англ. covariance shift)). <br />
<br />
Ковариантный сдвиг {{---}} это ситуация, когда распределения значений признаков в обучающей и тестовой выборке имеют разные параметры (математическое ожидание, дисперсия и т.д.). Ковариантность в данном случае относится к значениям признаков.<br />
<br />
Проиллюстрируем ковариантный сдвиг примером. <br />
Пусть есть [[Глубокое обучение|глубокая нейронная сеть]], которая обучена определять находится ли на изображении роза.<br />
И нейронная сеть была обучена на изображениях только красных роз. <br />
Теперь, если попытаться использовать обученную модель для обнаружения роз различных цветов, то, очевидно, точность работы модели будет неудовлетворительной.<br />
Это происходит из-за того, что обучающая и тестовая выборки содержат изображения красных роз и роз различных цветов в разных пропорциях. <br />
Другими словами, если модель обучена отображению из множества <tex>X</tex> в множество <tex>Y</tex> и если пропорция элементов в <tex>X</tex> изменяется, то появляется необходимость обучить модель заново, чтобы "выровнять" пропорции элементов в <tex>X</tex> и <tex>Y</tex>. <br />
Когда пакеты содержат изображения разных классов, распределенные в одинаковой пропорции на всем множестве, то ковариантный сдвиг незначителен. <br />
Однако, когда пакеты выбираются только из одного или двух подмножеств (в данном случае, красные розы и розы различных цветов), то ковариантный сдвиг возрастает. <br />
Это довольно сильно замедляет процесс обучения модели. На Рисунке 1 изображена разница в пропорциях.<br />
<br />
Простой способ решить проблему ковариантного сдвига для входного слоя {{---}} это случайным образом перемешать данные перед созданием пакетов. <br />
Но для скрытых слоев нейронной сети такой метод не подходит, так как распределение входных данных для каждого узла скрытых слоев изменяется каждый раз, когда происходит обновление параметров в предыдущем слое. <br />
Эта проблема называется '''внутренним ковариантным сдвигом''' (англ. internal covariate shift). <br />
Для решения данной проблемы часто приходится использовать низкий [[Стохастический градиентный спуск|темп обучения]] (англ. learning rate) и методы [[wikipedia:ru:Регуляризация_(математика)|регуляризации]] при обучении модели. <br />
Другим способом устранения внутреннего ковариантного сдвига является метод пакетной нормализации.<br />
<br />
===Свойства пакетной нормализации===<br />
Кроме того, использование пакетной нормализации обладает еще несколькими дополнительными полезными свойствами:<br />
* достигается более быстрая сходимость моделей, несмотря на выполнение дополнительных вычислений;<br />
* пакетная нормализация позволяет каждому слою сети обучатся более независимо от других слоев;<br />
* становится возможным использование более высокого темпа обучения, так как пакетная нормализация гарантирует, что выходы узлов нейронной сети не будут иметь слишком больших или малых значений;<br />
* пакетная нормализация в каком-то смысле также является механизмом регуляризации: данный метод привносит в выходы узлов скрытых слоев некоторый шум, аналогично методу [[Практики реализации нейронных сетей#Dropout|dropout]];<br />
* модели становятся менее чувствительны к начальной инициализации весов.<br />
<br />
==Описание метода==<br />
Опишем устройство метода пакетной нормализации. Пусть на вход некоторому слою нейронной сети поступает вектор размерности <tex>d</tex>: <tex>x = (x^{(1)}, \ldots, x^{(d)})</tex>. Нормализуем данный вектор по каждой размерности <tex>k</tex>:<br />
<br />
<tex>\hat{x}^{(k)} = \displaystyle \frac{x^{(k)} - E(x^{(k)})}{\sqrt{D(x^{(k)})}}</tex>,<br />
<br />
где математическое ожидание и дисперсия считаются по всей обучающей выборке. Такая нормализация входа слоя нейронной сети может изменить представление данных в слое. Чтобы избежать данной проблемы, вводятся два параметра сжатия и сдвига нормализованной величины для каждого <tex>x^{(k)}</tex>: <tex>\gamma^{(k)}</tex>, <tex>\beta^{(k)}</tex> {{---}} которые действуют следующим образом:<br />
<br />
<tex>y^{(k)} = \gamma^{(k)} \hat{x}^{(k)} + \beta^{(k)}</tex>.<br />
<br />
Данные параметры настраиваются в процессе обучения вместе с остальными [[Модель_алгоритма_и_ее_выбор|параметрами модели]].<br />
<br />
Пусть обучение модели производится с помощью пакетов <tex>B</tex> размера <tex>m</tex>: <tex>B = \{x_{1},\ldots, x_{m}\}</tex>. Здесь нормализация применяется к каждому элементу входа с номером <tex>k</tex> отдельно, поэтому в <tex>x^{(k)}</tex> индекс опускается для ясности изложения. Пусть были получены нормализованные значения пакета <tex>\hat{x}_{1},\ldots, \hat{x}_{m}</tex>. После применения операций сжатия и сдвига были получены <tex>y_{1},\ldots, y_{m}</tex>. Обозначим данную функцию пакетной нормализации следующим образом:<br />
<br />
<tex>BN_{\gamma, \beta}: \{x_{1},\ldots, x_{m}\} \rightarrow \{y_{1},\ldots, y_{m}\}</tex><br />
<br />
Тогда алгоритм пакетной нормализации можно представить так:<br />
<br />
'''Вход''': значения <tex>x</tex> из пакета <tex>B = \{x_{1},\ldots, x_{m}\}</tex>; настраиваемые параметры <tex>\gamma, \beta</tex>; константа <tex>\epsilon</tex> для вычислительной устойчивости.<br />
'''Выход''': <tex>\{y_{i} = BN_{\gamma, \beta}(x_{i})\}</tex><br />
<tex>\mu_{B} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} x_{i}</tex> <font color="green">// математическое ожидание пакета</font><br />
<tex>\sigma_{B}^{2} = \displaystyle \frac{1}{m} \sum_{i=1}^{m} (x_{i} - \mu_{B})^{2}</tex> <font color="green">// дисперсия пакета</font><br />
<tex>\hat{x}_{i} = \displaystyle \frac{x_{i} - \mu_{B}}{\sqrt{\sigma_{B}^{2} + \epsilon}}</tex> <font color="green">// нормализация</font><br />
<tex>y_{i} = \gamma \hat{x}_{i} + \beta \equiv BN_{\gamma, \beta}(x_{i}) </tex> <font color="green">// сжатие и сдвиг</font><br />
<br />
Заметим, что если <tex>\beta=\mu_{B}</tex> и <tex>\gamma=\sqrt{\sigma_{B}^{2} + \epsilon}</tex>, то <tex>y_{i}</tex> равен <tex>x_{i}</tex>, то есть <tex>BN_{\gamma, \beta}(\cdot)</tex> является тождественным отображением.<br />
Таким образом, использование пакетной нормализации не может привести к снижению точности, поскольку оптимизатор просто может использовать нормализацию как тождественное отображение.<br />
<br />
==Обучение нейронных сетей с пакетной нормализацией==<br />
[[Файл:BNcircuit.png|700px|thumb|Рисунок 2. [[Настройка_глубокой_сети#Граф вычислений|Граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки. Слева-направо черными стрелками показана работа алгоритма в прямом направлении. А справа-налево красными стрелками {{---}} в обратном направлении, где вычисляется градиент функции потерь. Здесь <tex>N=m</tex> и <tex>D=d</tex>. Иллюстрация из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи].]]<br />
<br />
Для обучения нейронных сетей необходимо вычислять [[wikipedia:ru:Градиент|градиент]] [[wikipedia:en:Loss_function|функции потерь]] <tex>l</tex>. В случае использования метода пакетной нормализации градиент вычисляется следующим образом:<br />
<br />
<tex>\displaystyle \frac{\partial l}{\partial \hat{x}_{i}} = \frac{\partial l}{\partial y_{i}} \cdot \gamma</tex> <tex> (1)</tex><br />
<br />
<tex>\displaystyle \frac{\partial l}{\partial \sigma_{B}^{2}} = \sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot (x_{i} - \mu_{B}) \cdot \frac{-1}{2}(\sigma_{B}^{2} + \epsilon)^{-3/2}</tex> <tex> (2)</tex><br />
<br />
<tex>\displaystyle \frac{\partial l}{\partial \mu_{B}} = \left(\sum_{i=1}^{m}\frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{-1}{\sqrt{\sigma_{B}^{2} + \epsilon}}\right) + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{\sum_{i=1}^{m}-2(x_{i}-\mu_{B})}{m}</tex> <tex> (3)</tex><br />
<br />
<tex>\displaystyle \frac{\partial l}{\partial x_{i}} = \frac{\partial l}{\partial \hat{x}_{i}} \cdot \frac{1}{\sqrt{\sigma_{B}^{2} + \epsilon}} + \frac{\partial l}{\partial \sigma_{B}^{2}} \cdot \frac{2(x_{i}-\mu_{B})}{m} + \frac{\partial l}{\partial \mu_{B}} \cdot \frac{1}{m}</tex> <tex> (4)</tex><br />
<br />
<tex>\displaystyle \frac{\partial l}{\partial \gamma} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}} \cdot \hat{x}_{i}</tex> <tex> (5)</tex><br />
<br />
<tex>\displaystyle \frac{\partial l}{\partial \beta} = \sum_{i=1}^{m}\frac{\partial l}{\partial y_{i}}</tex> <tex> (6)</tex><br />
<br />
На Рисунке 2 изображен [[Настройка_глубокой_сети#Граф вычислений|граф вычислений]] слоя пакетной нормализации алгоритмом обратного распространения ошибки.<br />
<br />
В прямом направлении, как и описано в алгоритме метода, из входа <tex>x</tex> вычисляется среднее значение по каждой размерности признакового пространства. Затем полученный вектор средних значение вычитается из каждого элемента обучающей выборки. Далее вычисляется дисперсия, и с помощью нее вычисляется знаменатель для нормализации. Затем полученное значение инвертируется и умножается на разницу входа <tex>x</tex> и средних значений. В конце применяются параметры <tex>\gamma</tex> и <tex>\beta</tex>. <br />
<br />
В обратном направлении вычисляются производные необходимых функций. В следующей таблице подробнее изображены шаги вычисления градиента функции потерь (иллюстрации из [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html статьи], здесь <tex>N=m</tex> и <tex>D=d</tex>):<br />
<br />
{| cellpadding = "20" class = "wikitable"<br />
! Шаг !! Изображение !! Описание<br />
|-<br />
| style = "text-align: center" | 1<br />
|[[Файл:step9.png|300px]]<br />
|Сначала вычисляется производная по параметру <tex>\beta</tex>, как в уравнении <tex>(6)</tex>, так как к нему применяется только операции суммирования. И значение градиента выхода передается без изменений.<br />
|-<br />
| style = "text-align: center" | 2<br />
|[[Файл:step8.png|300px]]<br />
|Далее, пользуясь правилом вычисления производной при умножении, как в уравнении <tex>(5)</tex>, вычисляется градиент по параметру <tex>\gamma</tex>. Градиент выхода умножается на данную константу, получая уравнение <tex>(1)</tex>, и передается в следующий узел.<br />
|-<br />
| style = "text-align: center" | 3<br />
|[[Файл:step7.png|300px]]<br />
|Данный шаг вычисляется аналогично предыдущему, применяя правило вычисления производной при умножении.<br />
|-<br />
| style = "text-align: center" | 4<br />
|[[Файл:step6.png|300px]]<br />
|Пользуясь производной обратной величины, вычисляем следующий узел графа.<br />
|-<br />
| style = "text-align: center" | 5<br />
|[[Файл:step5.png|300px]]<br />
|Вычисляем производную квадратного корня с добавлением <tex>\epsilon</tex>.<br />
|-<br />
| style = "text-align: center" | 6<br />
|[[Файл:step4.png|300px]]<br />
|Вычисляем производную суммы по всем компонентам входного вектора, получая матрицу.<br />
|-<br />
| style = "text-align: center" | 7<br />
|[[Файл:step3.png|300px]]<br />
|Получаем производную квадрата входящей функции.<br />
|-<br />
| style = "text-align: center" | 8<br />
|[[Файл:step2.png|300px]]<br />
|На данном шаге в одном узле сходятся ветки, поэтому полученные производные просто складываются, получая уравнение <tex>(2)</tex> для производной по дисперсии.<br />
|-<br />
| style = "text-align: center" | 9<br />
|[[Файл:step1.png|300px]]<br />
|Аналогично шагу 6 вычисляем матрицу по сумме для производной по математическому ожиданию, получая формулу <tex>(3)</tex>.<br />
|-<br />
| style = "text-align: center" | 10<br />
|[[Файл:step0.png|300px]]<br />
|В начальной вершине получаем уравнение <tex>(4)</tex>, складывая входящие производные.<br />
|}<br />
<br />
==Пакетная нормализация в [[Сверточные нейронные сети | свёрточных сетях]]==<br />
Пакетная нормализация может быть применена к любой функции активации. Рассмотрим подробнее случай аффинного преобразования с некоторой нелинейной функцией:<br />
<br />
<tex>z = g(Wu + b)</tex>,<br />
<br />
где <tex>W</tex> и <tex>b</tex> {{---}} настраиваемые параметры модели, а <tex>g(\cdot)</tex> {{---}} некоторая нелинейная функция, например [[Практики реализации нейронных сетей#Sigmoid function|cигмоида]] или [[Практики реализации нейронных сетей#Rectified Linear Units (ReLU)|ReLU]]. Данной функцией можно описать как обычные, так и сверточные слои нейронных сетей. Пакетная нормализация применяется сразу перед функцией <tex>g(\cdot)</tex> к <tex>x = Wu + b</tex>. Параметр <tex>b</tex> может быть опущен, так как в дальнейших вычислениях его роль будет играть параметр <tex>\beta</tex>. Поэтому <tex>z = g(Wu + b)</tex> может быть записано так:<br />
<br />
<tex>z = g(BN(Wu))</tex>,<br />
<br />
где <tex>BN</tex> применяется отдельно к каждой размерности <tex>x=Wu</tex> с отдельной парой параметров <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> для каждой размерности.<br />
<br />
В случае свёрточных сетей, дополнительно необходима нормализация, чтобы удовлетворить свойство свёрточных сетей, что различные элементы в разных местах одной карты признаков (образ операции свёртки, англ. feature map) должны быть нормализованы одинаково. Чтобы этого добиться, нормализация выполняется совместно над всеми значениями в пакете. Пусть <tex>B</tex> {{---}} множество всех значений в карте признаков по всему пакету и всем точкам в карте признаков. Тогда для пакета размера <tex>m</tex> и карты признаков размера <tex>p \times q</tex> размер <tex>B</tex> равен <tex>m'=|B|=m \cdot pq</tex>. Тогда параметры <tex>\gamma^{(k)}</tex> и <tex>\beta^{(k)}</tex> настраиваются для каждой карты признаков отдельно.<br />
<br />
==Пример==<br />
[[File:bn_exp_1.png|300px|thumb|Рисунок 3. Точность распознавания в зависимости от итерации обучения. Оранжевая кривая изображает результаты для модели с использованием пакетной нормализации, синяя кривая {{---}} без. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]<br />
[[File:bn_exp_2.png|300px|thumb|Рисунок 4. Точность распознавания в зависимости от итерации обучения c использованием сигмоиды в качетсве функции активации. Иллюстрация из [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb статьи].]]<br />
<br />
Приведем пример демонстрирующий работу пакетной нормализации. <br />
Рассмотрим задачу распознавания рукописных цифр на известном датасете MNIST <ref>[http://yann.lecun.com/exdb/mnist/ Датасет MNIST]</ref>. <br />
Для решения задачи будет использоваться обычная нейронная сеть с <tex>3</tex> скрытыми полносвязными слоями по <tex>100</tex> узлов в каждом. <br />
Функция активации {{---}} ReLU. <br />
Выходной слой содержит <tex>10</tex> узлов. <br />
Размер пакета равен <tex>60</tex>. <br />
Сравниваются две одинаковые модели, но в первой перед каждым скрытым слоем используется пакетная нормализация, а во второй {{---}} нет. <br />
Темп обучения равен <tex>0.01</tex>. <br />
Веса инициализированы значениями с малой дисперсией. <br />
<br />
На Рисунке 3 изображены два графика, показывающие разницу между моделями. <br />
Как видно, обе модели достигли высокой точности, но модель с использованием пакетной нормализации достигла точности более <tex>90\%</tex> быстрее, почти сразу, и достигла максимума, примерно, уже на <tex>10000</tex> итераций. Однако, модель без пакетной нормализации достигла скорости обучения примерно <tex>510</tex> пакетов в секунду, а модель с использованием пакетной нормализации {{---}} <tex>270</tex>. <br />
Однако, как можно видеть, пакетная нормализация позволяет выполнить меньшее количество итераций и, в итоге, сойтись за меньшее время.<br />
<br />
На Рисунке 4 изображен график, сравнивающий точно такие же модели, но с использованием сигмоиды в качестве функции активации. <br />
Такая конфигурация моделей требует большего времени, чтобы начать обучение. <br />
В итоге, модель обучается, но на это потребовалось более <tex>45000</tex> итераций, чтобы получить точность более <tex>80\%</tex>. <br />
При использовании пакетной нормализации получилось достичь точность более <tex>90\%</tex> примерно за <tex>1000</tex> итераций.<br />
<br />
==Реализации==<br />
Механизм пакетной нормализации реализован практически во всех современных инструментариях для машинного обучения, таких как: TensorFlow <ref>[https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization TensorFlow]</ref>, Keras <ref>[https://keras.io/layers/normalization/ Keras]</ref>, CNTK <ref>[https://docs.microsoft.com/en-us/cognitive-toolkit/BatchNormalization CNTK]</ref>, Theano <ref>[http://deeplearning.net/software/theano/library/tensor/nnet/bn.html Theano]</ref>, PyTorch <ref>[https://pytorch.org/docs/stable/_modules/torch/nn/modules/batchnorm.html PyTorch]</ref> и т.д.<br />
<br />
Приведем пример<ref>[https://towardsdatascience.com/batch-normalization-theory-and-how-to-use-it-with-tensorflow-1892ca0173ad Batch normalization: theory and how to use it with Tensorflow]</ref> применения пакетной нормализации с использованием библиотеки TensorFlow на языке программирования Python <ref>[https://www.python.org/ Язык программирования Python]</ref>:<br />
<br />
'''import''' tensorflow '''as''' tf<br />
<font color=green># ...</font><br />
is_train = tf.placeholder(tf.bool, name="is_train");<br />
<font color=green># ...</font><br />
x_norm = tf.layers.batch_normalization(x, training=is_train)<br />
<font color=green># ...</font><br />
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)<br />
'''with''' tf.control_dependencies(update_ops):<br />
train_op = optimizer.minimize(loss)<br />
<br />
==Модификации==<br />
Существует несколько модификаций и вариаций метода пакетной нормализации:<br />
# Тим Койманс<ref>[https://arxiv.org/pdf/1603.09025.pdf Cooijmans T. {{---}} Recurrent batch normalization, 2016]</ref> в 2016 г. предложил способ применения пакетной нормализации к [[Рекуррентные нейронные сети|рекуррентным нейронным сетям]];<br />
# Расширение метода пакетной нормализации было предложено Ликси Хуангом<ref>[https://arxiv.org/pdf/1804.08450.pdf Huang L. {{---}} Decorrelated Batch Normalization, 2018]</ref> в 2018 г. Метод получил название декоррелированная пакетная нормализация (англ. Decorrelated Batch Normalization). В данном методе кроме операций масштабирования и сдвига была предложено использование специальной функции затирания данных; <br />
# Джимми Лей Ба<ref>[https://arxiv.org/pdf/1607.06450.pdf Ba J. L., Kiros J. R., Hinton G. E. {{---}} Layer normalization, 2016]</ref> в 2016 г. предложил метод нормализации слоев (англ. Layer Normalization), который решает проблему выбора размера пакета;<br />
# В работе Сергея Иоффе<ref>[https://arxiv.org/pdf/1702.03275.pdf Ioffe S. {{---}} Batch renormalization: Towards reducing minibatch dependence in batch-normalized models, 2017]</ref> в 2017 г. было представлено расширение метода пакетной нормализации: пакетная ренормализация (англ. Batch Renormalization). Данный метод улучшает пакетную нормализацию, когда размер пакетов мал и не состоит из независимых данных;<br />
# Метод потоковой нормализации (англ. Streaming Normalization) был предложен Кифэном Ляо<ref>[https://arxiv.org/pdf/1610.06160.pdf Liao Q., Kawaguchi K., Poggio T. {{---}} Streaming normalization: Towards simpler and more biologically-plausible normalizations for online and recurrent learning, 2016]</ref> в 2016 г. Данный метод убирает два ограничения пакетной нормализации: использование при [[wikipedia:ru:Онлайновое_обучение_машин|online-обучении]] и использование в рекуррентных нейронных сетях.<br />
<br />
==См. также==<br />
*[[:Глубокое обучение|Глубокое обучение]]<br />
*[[:Практики реализации нейронных сетей|Практики реализации нейронных сетей]]<br />
*[[:Настройка глубокой сети|Настройка глубокой сети]]<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
== Источники информации==<br />
* [https://arxiv.org/pdf/1502.03167.pdf Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift]<br />
* [https://towardsdatascience.com/batch-normalization-in-neural-networks-1ac91516821c Glossary of Deep Learning: Batch Normalisation]<br />
* [https://kratzert.github.io/2016/02/12/understanding-the-gradient-flow-through-the-batch-normalization-layer.html Understanding the backward pass through Batch Normalization Layer]<br />
* [https://medium.com/@SeoJaeDuk/deeper-understanding-of-batch-normalization-with-interactive-code-in-tensorflow-manual-back-1d50d6903d35 Deeper Understanding of Batch Normalization with Interactive Code in Tensorflow]<br />
* [https://www.learnopencv.com/batch-normalization-in-deep-networks/ Batch Normalization in Deep Networks]<br />
* [https://github.com/udacity/deep-learning/blob/master/batch-norm/Batch_Normalization_Lesson.ipynb Batch Normalization {{---}} Lesson]<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5&diff=69678Глубокое обучение2019-01-30T20:16:39Z<p>Dariyakovleva: </p>
<hr />
<div>[[Файл:Ml_areas.jpg|thumb|250px|Глубокое обучение как часть машинного обучения.]]<br />
<br />
'''Глубокое обучение''' (англ. deep learning) {{---}} совокупность широкого семейства методов машинного обучения, основанных на имитации работы человеческого мозга в процессе обработки данных и создания паттернов, используемых для принятия решений<ref>[https://www.investopedia.com/terms/d/deep-learning.asp Deep Learning, Investopedia]</ref>. Как правило, глубокое обучение предназначено для работы с большими объемами данных и использует сложные алгоритмы для обучения модели<ref>[https://www.quora.com/What-is-the-difference-between-Neural-Networks-and-Deep-Learning The difference between neural networks and deep learning]</ref>. На больших датасетах глубокое обучение показывает более высокую точность результатов в сравнении с традиционным машинным обучением. Зависимость производительности (качества результатов) от объема данных представлена на рисунке ниже.<br />
<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:Perfm_data.jpg|border|450px|thumb|left|Зависимость производительности от объема данных.]]<br />
|}<br />
<br />
Несмотря на то, что данный раздел машинного обучения появился еще в 1980-х, до недавнего времени его применение было сильно ограничено из-за недостатка вычислительных мощностей существовавших компьютеров. Ситуация изменилась только в середине 2000-х.<br />
<br />
На создание моделей глубокого обучения оказали влияние некоторые процессы и паттерны, происходящие в биологических нейронных системах. Несмотря на это, данные модели во многом отличаются от биологического мозга (и в структуре и в функциях), что делает невозможным использование теорем и доказательств, применяющихся в нейробиологии.<br />
<br />
== История ==<br />
* 1943 {{---}} Искусственный нейрон Маккаллока — Питтса<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref> {{---}} узел искусственной нейронной сети, являющийся упрощённой моделью естественного нейрона;<br />
* 1949 {{---}} Принцип обучения нейронов Хебба<ref>[https://en.wikipedia.org/wiki/Hebbian_theory Hebbian theory, Wikipedia]</ref> {{---}} изначально наблюдаемая причинно-следственная связь между активациями пре- и постсинаптического нейрона имеет тенденцию к усилению;<br />
* 1957 {{---}} Модель перцептрона предложена Фрэнком Розенблаттом<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref> {{---}} математическая или компьютерная модель восприятия информации мозгом;<br />
* 1960 {{---}} Дельта-правило обучения перцептрона<ref>[https://en.wikipedia.org/wiki/Delta_rule Delta rule, Wikipedia]</ref> {{---}} метод обучения перцептрона по принципу градиентного спуска по поверхности ошибки;<br />
* 1969 {{---}} Выход книги Марвина Минска и Сеймура Паперта "Перцептроны"<ref>[https://en.wikipedia.org/wiki/Perceptrons_(book) Perceptrons book, WIkipedia]</ref>. В данной книге математически показаны ограничения перцептронов;<br />
* 1974 {{---}} Метод обратного распространения ошибки впервые предложен А. И. Галушкиным и Дж. Вербосом<ref>[https://en.wikipedia.org/wiki/Backpropagation Backpropagation, Wikipedia]</ref> {{---}} метод вычисления градиента, который используется при обновлении весов многослойного перцептрона;<br />
* 1980 {{---}} Первая свёрточная нейронная сеть предложена Кунихико Фукусимой<ref>[https://en.wikipedia.org/wiki/Convolutional_neural_network Convolutional_neural_network, Wikipedia]</ref> {{---}} специальная архитектура искусственных нейронных сетей использующая некоторые особенности зрительной коры;<br />
* 1982 {{---}} Рекуррентные нейронные сети предложены Д. Хопфилдом {{---}} вид нейронных сетей, где связи между элементами образуют направленную последовательность;<br />
* 1991 {{---}} Проблема "исчезающего" градиента была сформулирована С. Хочрейтом. Проблема "исчезающего" градиента заключается в быстрой потере информации с течением времени;<br />
* 1997 {{---}} Долгая краткосрочная память предложена С. Хочрейтом и Ю. Шмидхубером<ref>[https://en.wikipedia.org/wiki/Long_short-term_memory Long short-term memory, Wikipedia]</ref>. В отличие от традиционных рекуррентных нейронных сетей, LSTM-сеть хорошо приспособлена к обучению на задачах классификации, обработки и прогнозирования временных рядов в случаях, когда важные события разделены временными промежутками с неопределённой продолжительностью и границами;<br />
* 1998 {{---}} Градиентный спуск для сверточных нейронных сетей предложен Я. Лекуном;<br />
* 2006 {{---}} Публикации Г. Хинтона, С. Осиндера и Я. Теха об обучении сетей глубокого доверия. Данные публикации, а также их активное освещение в средствах массовой информации смогли привлечь внимание ученых и разработчиков со всего мира к глубоким сетям;<br />
* 2012 {{---}} Предложение дропаута Г. Хинтоном, А. Крижевски и И. Шутковичем<ref>[https://en.wikipedia.org/wiki/Dropout_(neural_networks) Dropout, Wikipedia]</ref>. Дропаут (от англ. dropout) {{---}} метод регуляризации искусственных нейронных сетей, предназначен для предотвращения переобучения сети;<br />
* 2012 {{---}} Нейронные сети побеждают в ImageNet Challenge<ref>[https://en.wikipedia.org/wiki/ImageNet#ImageNet_Challenge ImageNet Challenge, Wikipedia]</ref>. Данное событие ознаменовало начало эры нейронных сетей и глубокого обучения;<br />
* 2014 {{---}} Группа исследователей под руководством Зеппа Хохрейтера использовала глубокое обучение для определения токсичного воздействия лекарств и бытовых средств на окружающую среду. Данна работа была отмечена первым местом на соревновании "Tox21 Data Challenge"<ref>[https://tripod.nih.gov/tox21/challenge/leaderboard.jsp Tox21 Data Challenge Winners]</ref>;<br />
* 2016 {{---}} Программа для игры в го Google AlphaGo выиграла со счётом 4:1 у Ли Седоля, лучшего международного игрока в эту игру. AlphaGo, разработанная DeepMind, использует глубокое обучение с помощью многоуровневых нейронных сетей;<br />
* 2018 {{---}} Глубокое обучение впервые используется для планирования лучевой терапии<ref>[https://aapm.onlinelibrary.wiley.com/doi/abs/10.1002/mp.13271 Automatic treatment planning based on three‐dimensional dose distribution predicted from deep learning technique]</ref>.<br />
<br />
В настоящее время глубокое обучение используется [[Глубокое обучение#Применения | во многих сферах]].<br />
<br />
== Определение == <br />
'''Глубокое обучение''' {{---}} это класс алгоритмов машинного обучения, который:<br />
<br />
* Использует многослойную систему нелинейных фильтров для извлечения признаков с преобразованиями. Каждый последующий слой получает на входе выходные данные предыдущего слоя; <br />
* Может сочетать алгоритмы [[Обучение с учителем | обучения с учителем]]<sup>[на 28.01.19 не создан]</sup> (пример {{---}} классификация) и [[Обучение без учителя | без учителя ]]<sup>[на 28.01.19 не создан]</sup> (пример {{---}} анализ образца);<br />
* Формирует в процессе обучения слои выявления признаков на нескольких уровнях представлений, которые соответствуют различным уровням абстракции; при этом признаки организованы иерархически {{---}} признаки более высокого уровня являются производными от признаков более низкого уровня;<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:Network_dif.png|border|550px|thumb|left|Глубокие и неглубокие нейронные сети.]]<br />
|}<br />
<br />
== Применения ==<br />
* Распознавание речи<ref>[https://en.wikipedia.org/wiki/Speech_recognition Speech recognition, Wikipedia]</ref>. Все основные коммерческие системы распознавания речи (например, Microsoft Cortana, Xbox, Skype Translator, Amazon Alexa, Google Now, Apple Siri, Baidu и iFlyTek) основаны на глубоком обучении;<br />
* [[:Задача нахождения объектов на изображении | Компьютерное зрение]]<sup>[на 28.01.19 не создан]</sup>. На сегодняшний день системы распознавания образов основанные на глубоком обучении уже умеют давать более точные результаты, чем человеческий глаз<ref>[https://www.sciencedirect.com/science/article/pii/S0893608012000524 Multi-column deep neural network for traffic sign classification]</ref>;<br />
* Обработка естественного языка<ref>[https://en.wikipedia.org/wiki/Natural_language_processing Natural language processing, Wikipedia]</ref>. Нейронные сети использовались для реализации языковых моделей еще с начала 2000-х годов. Изобретение LSTM помогло улучшить машинный перевод и языковое моделирование<ref>[https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf Sequence to Sequence Learning with Neural Networks]</ref>;<br />
* Обнаружение новых лекарственных препаратов. К примеру, нейронная сеть AtomNet использовалась для прогнозирования новых биомолекул {{---}} кандидатов для лечения таких заболевания, как вирус Эбола и рассеянный склероз;<br />
* Рекомендательные системы<ref>[https://en.wikipedia.org/wiki/Recommender_system Recommender system, Wikipedia]</ref>. На сегодняшний день глубокое обучение применяется для изучения пользовательских предпочтений во многих доменах;<br />
* Предсказание генномных онтологий в биоинформатике<ref>[https://en.wikipedia.org/wiki/Deep_learning#Bioinformatics Deep learning in bioinformatics, Wikipedia]</ref>.<br />
<br />
Полный список возможных применений глубокого обучения<ref>[https://en.wikipedia.org/wiki/Deep_learning#Applications Applications of deep learning, Wikipedia]</ref>.<br />
<br />
== Transfer learning ==<br />
[[Файл:Transfer.jpeg|border|450px|thumb|Transfer learning. Иллюстрация из [https://habr.com/company/binarydistrict/blog/428255/ статьи] на habr.com.]]<br />
'''Transfer learning''' {{---}} это применение к решению задачи знаний, извлеченных нейронной сетью при решении другой задачи. <br />
<br />
Глубокие нейронные сети требуют больших объемов данных для сходимости обучения. Поэтому часто встречается ситуация, когда для решаемой задачи недостаточно данных для того, чтобы хорошо натренировать все слои нейросети. Для решения этой проблемы и используется '''transfer learning'''<ref>[https://habr.com/company/binarydistrict/blog/428255/ Transfer Learning: как быстро обучить нейросеть на своих данных, habr.com]</ref>. <br />
<br />
Чаще всего '''transfer learning''' выглядит следующим образом: к натренированной на определенную задачу нейросети добавляется еще несколько скрытый слоев, которые позволяют использовать уже полученные знания для решения более конкретной задачи. Например, знания, полученные при обучении распознаванию различных предметов, могут применяться при решении задачи распознавания еды.<br />
<div style="clear:{{{1|both}}};"></div><br />
<br />
== Фреймворки для глубокого обучения ==<br />
* TensorFlow<ref>[https://en.wikipedia.org/wiki/TensorFlow TensorFlow, Wikipedia]</ref>;<br />
* Microsoft Cognitive Toolkit<ref>[https://en.wikipedia.org/wiki/Microsoft_Cognitive_Toolkit Microsoft Cognitive Toolkit, Wikipedia]</ref>;<br />
* Wolfram Mathematica<ref>[https://en.wikipedia.org/wiki/Wolfram_Mathematica Wolfram Mathematica, Wikipedia]</ref>;<br />
* Keras<ref>[https://en.wikipedia.org/wiki/Keras Keras, Wikipedia]</ref>;<br />
* Deeplearning4j<ref>[https://en.wikipedia.org/wiki/Deeplearning4j Deeplearning4j, Wikipedia]</ref>;<br />
* Caffe<ref>[https://en.wikipedia.org/wiki/Caffe_(software) Caffe, Wikipedia]</ref>;<br />
* Torch/PyTorch<ref>[https://habr.com/post/334380 PyTorch — ваш новый фреймворк глубокого обучения, habr]</ref>;<br />
* MXNet<ref>[https://mxnet.apache.org MXNet, official site]</ref>;<br />
* Chainer<ref>[https://chainer.org Chainer, official site]</ref>.<br />
Сопоставление фреймворков, библиотек и отдельных программ для глубокого обучения<ref>[https://en.wikipedia.org/wiki/Comparison_of_deep_learning_software Comparison of deep learning software, Wikipedia]</ref>.<br />
<br />
== См. также ==<br />
* [[:Нейронные сети, перцептрон]]<br />
* [[:Сверточные нейронные сети]]<br />
* [[:Рекуррентные нейронные сети]]<br />
* [[:Обучение с подкреплением]]<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
== Источники информации ==<br />
* [https://en.wikipedia.org/wiki/Deep_learning Deep learning, Wikipedia]<br />
* [https://ru.wikipedia.org/wiki/Глубокое_обучение Глубокое обучение, Wikipedia]<br />
* [http://www.deeplearningbook.org/ Deep Learning Book, MIT]<br />
* [https://towardsdatascience.com/multi-layer-neural-networks-with-sigmoid-function-deep-learning-for-rookies-2-bf464f09eb7f Multi-Layer Neural Networks with Sigmoid Function, Towards Data Science]<br />
* [https://www.kaggle.com/dansbecker/rectified-linear-units-relu-in-deep-learning Rectified Linear Units (ReLU) in Deep Learning, Kaggle]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80_%D0%B8_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%B1%D0%BB%D0%B8%D0%B6%D0%B0%D0%B9%D1%88%D0%B8%D1%85_%D1%81%D0%BE%D1%81%D0%B5%D0%B4%D0%B5%D0%B9&diff=69677Метрический классификатор и метод ближайших соседей2019-01-30T20:13:40Z<p>Dariyakovleva: </p>
<hr />
<div>'''Метрический классификатор''' (англ. similarity-based classifier) {{---}} алгоритм классификации, основанный на вычислении оценок сходства между объектами.<br />
<br />
Для формализации понятия сходства вводится функция расстояния между объектами <tex>\rho(x,x')</tex>. Как правило, не требуется, чтобы были выполнены все три аксиомы метрики {{---}} неравенство треугольника может нарушаться.<br />
<br />
'''Метод ближайших соседей''' {{---}} простейший метрический классификатор, основанный на оценивании сходства объектов. Классифицируемый объект относится к тому классу, которому принадлежат ближайшие к нему объекты обучающей выборки.<br />
<br />
'''Метод <tex>k</tex> ближайших соседей''' (англ. kNN {{---}} <tex>k</tex> Nearest Neighbours) {{---}} Для повышения надёжности классификации объект относится к тому классу, которому принадлежит большинство из его соседей {{---}} <tex>k</tex> ближайших к нему объектов обучающей выборки <tex>x_i</tex>. В задачах с двумя классами число соседей берут нечётным, чтобы не возникало ситуаций неоднозначности, когда одинаковое число соседей принадлежат разным классам.<br />
<br />
'''Метод взвешенных ближайших соседей''' {{---}} в задачах с числом классов 3 и более нечётность уже не помогает и ситуации неоднозначности всё равно могут возникать. Тогда <tex>i</tex>-му соседу приписывается вес <tex>w_i</tex>, как правило, убывающий с ростом ранга соседа <tex>i</tex>. Объект относится к тому классу, который набирает больший суммарный вес среди <tex>k</tex> ближайших соседей.<br />
<br />
== Описание алгоритма ==<br />
Пусть задана обучающая выборка пар "объект-ответ" <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex><br />
<br />
Пусть на множестве объектов задана функция расстояния <tex>\rho(x,x')</tex>. Эта функция должна быть достаточно адекватной моделью сходства объектов. Чем больше значение этой функции, тем менее схожими являются два объекта <tex>x, x'</tex>.<br />
<br />
Для произвольного объекта <tex>u</tex> расположим объекты обучающей выборки <tex>x_i</tex> в порядке возрастания расстояний до <tex>u</tex>:<br />
<br />
<tex>\rho(u,x_{1; u}) \leq \rho(u,x_{2; u}) \leq \cdots \leq \rho(u,x_{m; u})</tex>,<br />
где через <tex>x_{i; u}</tex> обозначается тот объект обучающей выборки, который является <tex>i</tex>-м соседом объекта <tex>u</tex>. Аналогичное обозначение введём и для ответа на <tex>i</tex>-м соседе: <tex>y_{i; u}</tex>. Таким образом, произвольный объект <tex>u</tex> порождает свою перенумерацию выборки. В наиболее общем виде алгоритм ближайших соседей есть:<br />
<tex>a(u) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] w(i,u)</tex>,<br />
<br />
где <tex>w(i,u)</tex> {{---}} заданная весовая функция, которая оценивает степень важности <tex>i</tex>-го соседа для классификации объекта <tex>u</tex>. Естественно полагать, что эта функция не отрицательна и не возрастает по <tex>i</tex> (поскольку чем дальше объект, тем меньший вклад он должен вносить в пользу своего класса).<br />
<br />
По-разному задавая весовую функцию, можно получать различные варианты метода ближайших соседей.<br />
<br />
<tex>w(i,u) = [i=1]</tex> {{---}} простейший метод ближайшего соседа;<br />
<br />
<tex>w(i,u) = [i\leq k]</tex> {{---}} метод <tex>k</tex> ближайших соседей;<br />
<br />
<tex>w(i,u) = [i\leq k] q^i</tex> {{---}} метод <tex>k</tex> экспоненциально взвешенных ближайших соседей, где предполагается константа <tex>q < 1</tex>;<br />
<br />
[[Файл:SimpleKnnExample.png|frame|none|super|upright=1|Пример классификации, методом 5 ближайших соседей]]<br />
<br />
== Использование ядер сглаживания ==<br />
При использовании линейной функции в качестве <tex>w(i, u)</tex> возможно совпадение суммарного веса для нескольких классов. Это приводит к неоднозначности ответа при классификации. Чтобы такого не происходило, используют функцию [[Ядра]]<sup>[на 28.01.18 не создан]</sup>.<br />
<br />
Будем обозначать функцию ядра <tex>K(r)</tex>.<br />
<br />
=== Примеры ядер ===<br />
<br />
Triangular: <tex>{\displaystyle K(r)=(1-|r|)}</tex>,<br />
<br />
Parabolic: <tex>{\displaystyle K(r)={\frac {3}{4}}(1-r^{2})}</tex>,<br />
<br />
Tricube: <tex>{\displaystyle K(r)={\frac {70}{81}}(1-{\left|r\right|}^{3})^{3}}</tex>.<br />
<br />
=== Метод парзеновского окна ===<br />
<br />
Алгоритм <tex>k</tex> ближайших соседей можно обобщить с помощью функции ядра. Рассмотрим два способа, которыми это можно сделать.<br />
<br />
<tex>w(i,u) = K\biggl(\frac{\rho(u,x_{i; u})}{h}\biggr)</tex> {{---}} метод парзеновского окна фиксированной ширины <tex>h</tex>;<br />
<br />
<tex>w(i,u) = K\biggl(\frac{\rho(u,x_{i; u})}{\rho(u,x_{k+1; u})}\biggr)</tex> {{---}} метод парзеновского окна переменной ширины;<br />
<br />
Сравним два этих метода. Сперва запишем классификаторы, полученные при использовании этих методов, в явном виде:<br />
<br />
Фиксированной ширины: <tex>a_h = a(u, X^m, \boldsymbol{h}, K) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] K\biggl(\frac{\rho(u,x_{i; u})}{h}\biggr)</tex>,<br />
<br />
Переменной ширины: <tex>a_k = a(u, X^m, \boldsymbol{k}, K) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] K\biggl(\frac{\rho(u,x_{i; u})}{\rho(u,x_{k+1; u})}\biggr)</tex>.<br />
<br />
<tex>a_h</tex> не будет учитывать соседей на расстояние больше чем <tex>h</tex>, а всех остальных учтет в соответствии с функций ядра <tex>K</tex>. <br />
<tex>a_k</tex> является аналогом метода <tex>k</tex> ближайших соседей (т.к. для всех <tex>k+i</tex>-ых соседей функция <tex>K</tex> вернет 0), но при этом чем ближе <tex>k-i</tex>-ый сосед, тем больший вклад в сторону своего класса он даст.<br />
<br />
Часто используют окно переменной ширины т.е. классификатор <tex>a_k</tex>, по следующим причинам:<br />
<br />
# Удобнее оптимизировать целочисленный параметр <tex>k</tex>, чем вещественный параметр <tex>h</tex> по некоторой сетке;<br />
<br />
# Существует большое количество задач, где точки разбросаны неравномерно. В них могут существовать области, где достаточно брать небольшую <tex>h</tex> и области, где в окно ширины <tex>h</tex> попадает только одна точка. Тогда для классификатора <tex>a_h</tex> будут существовать области в которых не будет ни одного объекта (кроме того, который нужно классифицировать). Для таких областей не понятно как классифицировать объекты. <br />
<br />
[[Файл:KnnExample.png|frame|none|super|upright=1|Пример классификации, методом с постоянной шириной окна, и неравномерным разбросом точек]]<br />
<br />
== Использование различных метрик расстояния ==<br />
Очень редко известна хорошая функция расстояния <tex>\rho(x,x')</tex>. В качестве нее обычно использую следующие функции:<br />
<br />
=== Примеры метрик ===<br />
Пусть <tex>x</tex>, <tex>y</tex> {{---}} объекты, а <tex>(x_1, x_2,..., x_n)</tex>, <tex>(y_1, y_2,..., y_n)</tex> их признаковые описания.<br />
<br />
Евклидова метрика: <tex>\rho(x,y) = \sqrt {\sum _{i=1}^{n}(x_{i}-y_{i})^{2}}</tex>,<br />
<br />
Расстояние Чебышёва: <tex>\rho(x,y)=\max _{i=1,\dots ,n}|x_{i}-y_{i}|</tex>,<br />
<br />
Манхэттенское Расстояние: <tex>\rho(x,y)=\sum _{i=1}^{n}|x_{i}-y_{i}|</tex>.<br />
<br />
<br />
При их использовании важно нормировать значения признаков, иначе один признак с максимальным значением может стать преобладающим, а признаки с маленькими значениями не будут учитываться при классификации. Чтобы отсеять лишние признаки (т.е. не влияющие на класс объекта) можно использовать [http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8 feature selection].<br />
<br />
== Пример использования (через scikit-learn) ==<br />
<br />
Рассмотрим использование алгоритма <tex>kNN</tex> на примере [https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29 реального набора данных].<br />
Предположим, что мы загрузили <tex>wdbc.data</tex> и сохранили как <tex>tr.csv</tex> с заголовком {{---}} описанием признаков.<br />
<br />
* Загружаем данные<br />
<br />
'''import''' pandas '''as''' pd <br />
'''from''' sklearn.preprocessing '''import''' StandardScaler <br />
<br />
'''def''' load_data(data_path):<br />
ds = pd.read_csv(data_path, names=["id", "diagnosis", "radius_mean", "texture_mean", "perimeter_mean", "area_mean",<br />
"smoothness_mean", "compactness_mean", "concavity_mean", "concave points_mean",<br />
"symmetry_mean", "fractal_dimension_mean", "radius_se", "texture_se",<br />
"perimeter_se", "area_se", "smoothness_se", "compactness_se", "concavity_se",<br />
"concave points_se", "symmetry_se", "fractal_dimension_se", "radius_worst",<br />
"texture_worst", "perimeter_worst", "area_worst", "smoothness_worst",<br />
"compactness_worst", "concavity_worst", "concave points_worst", "symmetry_worst",<br />
"fractal_dimension_worst"])<br />
y = ds['diagnosis']<br />
X = ds.drop('diagnosis', axis=1)<br />
X = X.drop('id', axis=1)<br />
i = len(X.columns)<br />
X = X.drop(X.columns[i - 1], axis=1)<br />
y.replace(('M', 'B'), (1, 0), inplace=True)<br />
sc = StandardScaler()<br />
sc.fit(X)<br />
X_ans = sc.transform(X)<br />
return X_ans, y<br />
<br />
X, y = load_data("tr.csv")<br />
<br />
<br />
Теперь <tex>X</tex>, <tex>y</tex> {{---}} нормированные значения признаков и соответствующие им классы.<br />
<br />
* Делим данные на тренировочное и тестовое множество:<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)<br />
<br />
* Создаем классификатор:<br />
'''from''' sklearn.neighbors '''import''' KNeighborsClassifier<br />
<br />
best_model = KNeighborsClassifier(<br />
'''n_neighbors'''=10, <br />
'''weights'''=’distance’,<br />
'''algorithm'''=’auto’,<br />
'''leaf_size'''=30,<br />
'''metric'''=’euclidean’,<br />
'''metric_params'''=None,<br />
'''n_jobs'''=4<br />
)<br />
<br />
* Обучаемся:<br />
<br />
best_model.fit(X_train, y_train)<br />
<br />
<br />
* Используем скользящий контроль для поиска лучших параметров (англ. cross validation):<br />
'''from''' sklearn.model_selection '''import''' GridSearchCV<br />
<br />
model_params = best_model.get_params()<br />
tuned_params = {}<br />
for k, v in model_params.items():<br />
tuned_params[k] = [v]<br />
tuned_params['n_neighbors'] = range(1, 30)<br />
clf = GridSearchCV(KNeighborsClassifier(), tuned_params, cv=10, n_jobs=-1)<br />
clf.fit(X_train, y_train)<br />
best_params = clf.best_params_<br />
<br />
* Оценка классификатора:<br />
'''from''' sklearn '''import''' metrics<br />
<br />
best_model = KNeighborsClassifier(**best_params)<br />
best_model.fit(X_train, y_train)<br />
predicted = best_model.predict(X_test)<br />
<br />
* Выводим результат:<br />
print('Used params:', best_params)<br />
print('Evaluation:\n', metrics.classification_report(y_test, predicted))<br />
<br />
> '''Used params''': {'metric_params': None, 'metric': 'euclidean', 'weights': 'distance', 'n_neighbors': 9, 'leaf_size': 30, 'n_jobs': 4, 'p': 2, 'algorithm': 'auto'}<br />
'''Evaluation:'''<br />
precision recall f1-score support<br />
0 0.90 1.00 0.95 69<br />
1 1.00 0.82 0.90 45<br />
micro avg 0.93 0.93 0.93 114<br />
macro avg 0.95 0.91 0.92 114<br />
weighted avg 0.94 0.93 0.93 114<br />
<br />
==Пример на языке Scala==<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.knn<ref>[https://haifengl.github.io/smile/classification.html#knn Smile, KNN]</ref>:<br />
'''import '''smile.classification._<br />
'''import '''smile.data._<br />
'''import '''smile.plot._<br />
'''import '''smile.read<br />
'''import '''smile.validation.FMeasure<br />
<br />
'''val '''toy: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = toy.x()<br />
'''val '''y: Array['''Int'''] = toy.y().map(_.toInt)<br />
'''val '''KNN: KNN[Array['''Double''']] = knn(x, y, 3)<br />
'''val '''predictions: Array['''Int'''] = x.map(KNN.predict)<br />
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)<br />
plot(x, y, KNN)<br />
<br />
== См. также ==<br />
* [[Обзор библиотек для машинного обучения на Python]]<br />
* [[Общие понятия]]<br />
* [[Уменьшение размерности]]<br />
<br />
== Источники информации ==<br />
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80 Метрический классификатор] - статья на machinelearning.ru про метрический классификатор<br />
# [http://www.machinelearning.ru/wiki/index.php?title=KNN kNN] - статья на machinelearning.ru про kNN<br />
# [https://www.youtube.com/watch?v=l1xGQMowWA4&t=0s&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=3 лекция про kNN] - Лекция из курса К.В. Воронцова<br />
# [https://en.wikipedia.org/wiki/Kernel_(statistics) Функции ядер] - примеры ядер с Википедии<br />
# [https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html sklearn] - документация по scikit-learn<br />
# [https://www.kaggle.com/jeffbrown/knn-classifier/data kaggle example] - пример по работе с датасетом с kaggle<br />
<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Метрический классификатор]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D1%81%D0%BB%D1%83%D1%87%D0%B0%D0%B9%D0%BD%D1%8B%D0%B9_%D0%BB%D0%B5%D1%81&diff=69676Дерево решений и случайный лес2019-01-30T20:07:24Z<p>Dariyakovleva: </p>
<hr />
<div>Дерево решений {{---}} логический алгоритм классификации, решающий задачи классификации и регрессии. Представляет собой объединение логических условий в структуру дерева.<br />
<br />
==Дерево решений==<br />
<br />
{{Определение<br />
|id=def1. <br />
|neat = <br />
|definition=<br />
'''Дерево решений''' (англ. ''decision tree, DT'') {{---}} алгоритм классификации <tex>a(x) = (V_{внутр}, v_0, V_{лист}, S_v, \beta_v)</tex>, задающийся деревом (связным ациклическим графом), где:<br />
* <tex> V = V_{внутр} \cup V_{лист} </tex> {{---}} множество вершин , <tex>v_0 \in V</tex> {{---}} корень дерева;<br />
* <tex> S_v : D_v \rightarrow V_v </tex> {{---}} функция перехода по значению предиката в множество детей вершины <tex>v</tex>;<br />
* <tex> \beta_v : X \rightarrow D_v </tex> {{---}} предикат ветвления, <tex>v \in V_{внутр}</tex> и <tex>|D_v| < \infty</tex>;<br />
* Для листьев <tex>v \in V_{лист}</tex> определена метка класса <tex>y_v \in Y</tex>.<br />
}}<br />
{{Определение<br />
|id=def1 <br />
|neat =<br />
|definition=<br />
'''Бинарное дерево решений''' {{---}} частный случай дерева решений, для которого <tex> D_v = \{0,1\} </tex>.<br />
}}<br />
[[Файл:BinDT.jpg |300px|thumb|right|Классификация объекта <tex> x \in X </tex> бинарным решающим деревом]]<br />
<br />
'''function''' classify(x):<br />
<tex>v = v_0</tex><br />
'''if''' <tex>\beta_v(x) = 1 </tex> <br />
<tex>v := R_v</tex><br />
'''else'''<br />
<tex>v := L_v</tex><br />
'''return''' <tex>y_v</tex><br />
<br />
===Информативность ветвления===<br />
Для того, чтобы оценивать качество разбиения объектов по предикату <tex>\beta</tex>, введем понятие ''информационного выигрыша'' разбиения. <br><br />
Сначала оценим распределение значений классов объектов внутри каждого множества из разбиения, введя понятие ''меры неопределенности распределения''.<br />
{{Определение<br />
|id=def1 <br />
|neat =<br />
|definition=<br />
'''Частотная оценка вероятности класса <tex>y</tex> в вершине <tex>v \in V_{внутр}</tex> ''': <br><br />
<tex>p_y = P(y | x \in U) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}[y_i = y]</tex><br />
}}<br />
<br />
{{Определение<br />
|id=def1 <br />
|neat =<br />
|definition=<br />
'''Мера неопределенности (англ. ''impurity'') распределения <tex>p_y</tex>''': <br><br />
* минимальна, когда <tex>p_y \in \{0,1\}</tex>;<br />
* максимальна, когда <tex>p_y = \frac{1}{|Y|}</tex> для всех <tex>y \in Y</tex>;<br />
* не зависит от перенумерации классов<br />
<tex>Ф(U) = \sum\nolimits_{y \in Y} p_y L(p_y) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}L(P(y_i | x_i \in U)) \rightarrow min</tex>, <br> где <tex>L(p)</tex> убывает и <tex>L(1) = 0</tex>, например: <tex>-log_2(p)</tex>, <tex>1 - p</tex>, <tex>1 - p^2</tex><br />
}}<br />
<br />
Примерами мер неопределенности распределения являются: <br />
* Энтропия: <tex>Ф(U) = -\sum\limits_{i}^N p_i log_2p_i</tex>, определяется для каждого множества из разбиения, <tex>N</tex> {{---}} количество возможных классов, и <tex>p_i</tex> {{---}} вероятность объекта принадлежать <tex> i</tex>-ому классу.<br />
* Критерий Джини: <tex>Ф(U) = \sum\nolimits_{i != j}p_i p_j = \sum\nolimits_{i}p_i*(1-p_i)</tex>, максимизацию этого критерия можно интерпретировать как максимизацию числа пар объектов одного класса, оказавшихся после разбиения в одном множестве. <br><br />
<br />
Теперь определим суммарную ''неопределенность распределения'' в разбиении.<br />
{{Определение<br />
|id=def1 <br />
|neat =<br />
|definition=<br />
'''Неопределенность распределения <tex>P(y_i | x_i \in U_{\beta(x_i)})</tex> после ветвления вершины <tex>v</tex> по предикату <tex>\beta</tex> и разбиения <tex>U = \bigcup_{k \in D_v} U_k</tex>''': <br><br />
<tex>Ф(U_0, ... ,U_{D_v}) = \frac{1}{|U|} \sum\nolimits_{k \in D_v} \sum\nolimits_{x_i \in U_k}L(P(y_i | x_i \in U_k)) = \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k)</tex><br />
}}<br />
<br />
''Информационный выигрыш'' от разбиения определяется как изменение неопределенности в системе.<br />
{{Определение<br />
|id=def1 <br />
|neat =<br />
|definition=<br />
'''Информационный выигрыш от разбиения по предикату <tex>\beta</tex>''' <br><br />
<tex>Gain(\beta, U) = Ф(U) - Ф(U_1, ... ,U_{|D_v|}) = Ф(U) - \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k) \rightarrow max_{\beta \in B} </tex><br />
}}<br />
<br />
=== Рекурсивный алгоритм построения бинарного дерева решений ID3 ===<br />
Покажем идею построения дерева решения на частном случае бинарного дерева. Алгоритм <tex>ID3</tex> (англ. ''Induction of Decision Tree'') заключается в последовательном дроблении выборки на две части до тех пор, пока в каждой части не окажутся объекты только одного класса. Разделение производится по предикату <tex>\beta</tex>, который выбирается из множества элементарных предикатов. На практике в качестве элементарных предикатов чаще всего берут простые пороговые условия вида <tex>\beta(x) = [f_j(x) >= d_j]</tex>. <br />
<br>Проще всего записать этот алгоритм в виде рекурсивной процедуры <tex>ID3</tex>, которая строит дерево по заданной подвыборке <tex>U</tex> и возвращает его корневую вершину. <br />
<br />
1:'''function''' ID3(<tex>U</tex>):<br />
2: '''if''' <tex>for all</tex> <tex>u \in U</tex>: <tex>y_u = y</tex>, <tex>y \in Y</tex><br />
<font color=green>// создать листовую вершину <tex>v</tex> c меткой класса <tex>y_v</tex> </font><br />
3: v = createLeafVertex(<tex>y_v</tex>)<br />
4: '''return''' v<br />
<font color=green>// найти предикат с максимальным информационным выигрышом </font><br />
<tex>\beta= \mathrm{arg}\max_{\beta\in B} </tex> Gain(<tex>\beta</tex>, <tex>U</tex>)<br />
<font color=green>// разбить выборку на две части <tex>U = U_0 \cup U_1</tex> по предикату <tex>\beta</tex> </font><br />
5: <tex>U_0 := \{x \in U: \beta(x) = 0\}</tex><br />
6: <tex>U_1 := \{x \in U: \beta(x) = 1\}</tex><br />
7: '''if''' <tex>U_0 = \emptyset</tex> || <tex>U_1 = \emptyset</tex> <br />
<font color=green>// найти класс, в котором находится большинство объектов из <tex>U</tex> </font><br />
8: <tex>y_v</tex> = majorClass(<tex>U</tex>)<br />
9: v = createLeafVertex(<tex>y_v</tex>)<br />
'''else'''<br />
<font color=green>// создать внутреннюю вершину <tex>v</tex></font><br />
10: v = createVertex()<br />
11: <tex>\beta_v = \beta</tex><br />
12: <tex>S_0</tex> = ID3(<tex>U_0</tex>)<br />
13: <tex>S_1</tex> = ID3(<tex>U_1</tex>)<br />
14: '''return''' <tex>v</tex><br />
<br />
== Редукция решающих деревьев ==<br />
Суть редукции (англ. ''pruning'') состоит в удалении поддеревьев, имеющих недостаточную статистическую надёжность. При этом дерево перестаёт безошибочно классифицировать обучающую выборку, зато качество классификации новых объектов, как правило, улучшается. Рассмотрим наиболее простые варианты редукции.<br />
<br />
===Предредукция===<br />
Предредукция (англ. ''pre-pruning'') или критерий раннего останова досрочно прекращает дальнейшее ветвление в вершине дерева, если информативность <tex>I(\beta, U)</tex> для всех возможных предикатов <tex>\beta</tex> не дотягивает до заданного порогового значения <tex>I_0</tex>. <br><br />
Для этого на шаге 8 алгоритма <tex>ID3</tex> условие <tex>U_0 = \emptyset</tex> или <tex>U_1 = \emptyset</tex> заменяется условием <tex>I(\beta, U) <= I_0 </tex>. Порог <tex>I_0 </tex> является управляющим параметром метода. <br><br />
Предредукция считается не самым эффективным способом избежать переобучения, так как жадное ветвление по-прежнему остаётся глобально неоптимальным. Более эффективной считается cтратегия постредукции.<br />
<br />
===Постредукция===<br />
Постредукция (англ. ''post-pruning'') просматривает все внутренние вершины дерева и заменяет отдельные вершины либо одной из дочерних вершин (при этом вторая дочерняя удаляется), либо терминальной вершиной. Процесс замен продолжается до тех<br />
пор, пока в дереве остаются вершины, удовлетворяющие критерию замены. <br><br><br />
''Критерием замены'' является сокращение числа ошибок на контрольной выборке, отобранной заранее, и не участвовавшей в обучении дерева. Стандартная рекомендация — оставлять в контроле около 30% объектов. <br><br><br />
Для реализации постредукции контрольная выборка <tex>X^k</tex> пропускается через<br />
построенное дерево. При этом в каждой внутренней вершине <tex>v</tex> запоминается подмножество <tex>S_v \subseteq X_k</tex> попавших в неё контрольных объектов. Если <tex>S_v = \emptyset </tex>, то вершина <tex>v</tex> считается ненадёжной и заменяется терминальной по ''мажоритарному правилу'': <br><br />
в качестве <tex>y_v</tex> берётся тот класс, объектов которого больше всего в обучающей подвыборке <tex>U</tex>, пришедшей в вершину <tex>v</tex>. <br><br />
Затем для каждой внутренней вершины <tex>v</tex> вычисляется число ошибок, полученных при классификации выборки <tex>S_v</tex> следующими способами: <br><br />
* <tex>r(v)</tex> — классификация поддеревом, растущим из вершины <tex>v</tex>;<br />
* <tex>r_L(v)</tex> — классификация поддеревом левой дочерней вершины <tex>L_v</tex>;<br />
* <tex>r_R(v)</tex> — классификация поддеревом правой дочерней вершины <tex>R_v</tex>;<br />
* <tex>r_c(v)</tex> — отнесение всех объектов выборки <tex>S_v</tex> к классу <tex>y \in Y</tex>. <br><br />
Эти величины сравниваются, и в зависимости от того, какая из них оказалась<br />
минимальной, принимается, соответственно, одно из четырёх решений: <br><br />
* сохранить поддерево вершины <tex>v</tex>;<br />
* заменить поддерево вершины <tex>v</tex> поддеревом левой дочерней вершины <tex>L_v</tex>;<br />
* заменить поддерево вершины <tex>v</tex> поддеревом правой дочерней вершины <tex>R_v</tex>;<br />
* заменить поддерево <tex>v</tex> терминальной вершиной класса <tex>y_v = \mathrm{arg}\min_{y\in Y}r_c(v) </tex>.<br />
<br />
== Алгоритмы построения деревьев решения ==<br />
Недостатки рассмотренного алгоритма ID3: <br />
* Применим только для дискретных значений признаков;<br />
* Переобучение;<br />
* На каждом шаге решение принимается по одному атрибуту.<br />
<br />
=== Алгоритм [https://en.wikipedia.org/wiki/Predictive_analytics#Classification_and_regression_trees_.28CART.29 CART] (англ. ''Classification And Regression Trees'')===<br />
* В отличие от ID3 работает и с непрерывными значениями признаков: на каждом шаге построения дерева последовательно сравнивает все возможные разбиения для всех атрибутов и выбирает наилучший атрибут и наилучшее разбиение для него. Разбивает объекты на две части;<br />
* Использует редукцию для избежания переобучения;<br />
* Обрабатывает пропущенные или аномальные значения признаков.<br />
<br />
=== Алгоритм [https://en.wikipedia.org/wiki/C4.5_algorithm C4.5] ===<br />
* Также работает и с непрерывными значениями признаков: на каждом шаге построения дерева выбирает правило разбиения по одному из признаков. Разбивает объекты на несколько частей по этому правилу, рекурсивно запускается из полученных подмножеств;<br />
* Использует редукцию для избежания переобучения;<br />
* Обрабатывает пропущенные или аномальные значения признаков.<br />
<br />
== Случайный лес ==<br />
Случайный лес {{---}} один из примеров объединения классификаторов в [[Виды_ансамблей|ансамбль]]. <br><br />
Алгоритм построения случайного леса, состоящего из <tex>N</tex> деревьев на основе обучающей выборки <tex>X</tex> такой:<br />
'''for''' (n: 1,...,N):<br />
<font color=green>// сгенерировать выборку <tex>X_n</tex> c помощью [[Виды_ансамблей#Бутстрэп|бутстрэпа]]</font><br />
<tex>X_n</tex> = bootstrap(<tex>X</tex>)<br />
<font color=green>// построить решающее дерево <tex>t_n</tex> по выборке <tex>X_n</tex></font><br />
<tex>t_n</tex> = ID3(<tex>X_n</tex>) <br><br />
<br />
Итоговый классификатор {{---}} <tex>a(x) = \frac{1}{N} \sum\limits_{i = 1}^{N} t_i(x)</tex>. Для задачи классификации мы выбираем решение по большинству результатов, выданных классификаторами, а в задаче регрессии {{---}} по их среднему значению. <br><br />
<br />
Таким образом, случайный лес {{---}} бэггинг над решающими деревьями, при обучении которых для каждого разбиения признаки выбираются из некоторого случайного подмножества признаков.<br />
<br />
== Примеры использования (в scikit-learn) ==<br />
*Для решения задач классификации и регрессии используют [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier DecisionTreeClassifier], [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html#sklearn.tree.DecisionTreeRegressor DecisionTreeRegressor];<br />
<br />
*В '''sklearn.ensemble''' также представлены методы классификации, основанные на ансамблях, в том числе: [https://scikit-learn.org/stable/modules/ensemble.html#bagging бэггинг] и [https://scikit-learn.org/stable/modules/ensemble.html#forest случайный лес], которые были описаны выше. <br />
<br>Так, в этом примере создается бэггинг ансамбль из классификаторов '''KNeighborsClassifier''', каждый из которых обучен на случайных подмножествах из 50% объектов из обучающей выборки, и 50% случайно выбранных признаков.<br />
<br />
'''from''' sklearn.ensemble '''import''' BaggingClassifier<br />
'''from''' sklearn.neighbors '''import''' KNeighborsClassifier<br />
bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5)<br />
<br />
Пример использования классификатора на случайном лесе:<br />
Полную версию кода можно найти [https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html#sphx-glr-download-auto-examples-classification-plot-classifier-comparison-py| здесь]<br />
'''from''' sklearn '''import''' RandomForestClassifier<br />
'''from''' sklearn.datasets '''import''' make_classification<br />
<font color=green>// сгенерируем случайную обучающую выборку с классификацией по n_classes классам</font><br />
X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,<br />
random_state=1, n_clusters_per_class=1, n_classes=2)<br />
<font color=green>// разбиваем выборку на обучающую и тестовую </font><br />
X = StandardScaler().fit_transform(X)<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)<br />
<font color=green>// создадим классификатор на случайном лесе, состоящим из n_estimators деревьев</font><br />
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1)<br />
clf.fit(X_train, y_train)<br />
score = clf.score(X_test, y_test)<br />
<br />
Результат классификации показан на рисунке. <br />
<br />
[[Файл:RFC.png |800px|thumb|center|Классификация RandomForestClassifier. Кружочками изображены объекты обучающей выборки, крестиками тестовой выборки. Справа цветом выделены границы принятия решений, в правом нижнем углу {{---}} значение accuracy.]]<br />
<br />
== Пример на языке Scala ==<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.cart<ref>[https://haifengl.github.io/smile/classification.html#cart Smile, Decision Trees]</ref>:<br />
'''import '''smile.classification._<br />
'''import '''smile.data._<br />
'''import '''smile.plot._<br />
'''import '''smile.read<br />
'''import '''smile.validation.FMeasure<br />
<br />
'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = iris.x()<br />
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)<br />
'''val '''dt: DecisionTree = cart(x, y, 1000)<br />
'''val '''predictions: Array['''Int'''] = x.map(dt.predict)<br />
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)<br />
plot(x, y, dt)<br />
<br />
== См. также ==<br />
* [[Виды ансамблей]]<br />
<br />
== Источники информации ==<br />
# [http://www.machinelearning.ru/wiki/images/3/3e/Voron-ML-Logic.pdf Логические алгоритмы классификации] {{---}} Лекция К. В. Воронцова<br />
# [https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-5-ensembles-of-algorithms-and-random-forest-8e05246cbba7 Случайный лес] {{---}} статья на Medium, Yury Kashnitskiy<br />
# [https://scikit-learn.org/stable/modules/tree.html Деревья решений] {{---}} scikit-learn.org<br />
#[https://scikit-learn.org/stable/modules/ensemble.html Ансамбли классификаторов] — scikit-learn.org.<br />
<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Классификация и регрессия]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F&diff=69675Кластеризация2019-01-30T19:59:17Z<p>Dariyakovleva: </p>
<hr />
<div>[[Файл:clusters.png|thumb|300px|Пример кластеризации]]<br />
'''Кластеризация''' (англ. ''cluster analysis'') {{---}} задача группировки множества объектов на подмножества ('''кластеры''') таким образом,<br />
чтобы объекты из одного кластера были более похожи друг на друга, чем на объекты из других кластеров по какому-либо критерию.<br />
<br />
Задача кластеризации относится к классу задач обучения без учителя.<br />
== Постановка задачи кластеризации ==<br />
Пусть <tex>X</tex> {{---}} множество объектов, <tex>Y</tex> {{---}} множество идентификаторов (меток) кластеров.<br />
На множестве <tex>X</tex> задана функция расстояния между объектами <tex>\rho(x,x')</tex>.<br />
Дана конечная обучающая выборка объектов <tex>X^m = \{ x_1, \dots, x_m \} \subset X</tex>.<br />
Необходимо разбить выборку на подмножества (кластеры), то есть каждому объекту <tex>x_i \in X^m</tex> сопоставить метку <tex>y_i \in Y</tex>,<br />
таким образом чтобы объекты внутри каждого кластера были близки относительно метрики <tex>\rho</tex>, а объекты из разных кластеров значительно различались.<br />
{{Определение<br />
|definition =<br />
'''Алгоритм кластеризации''' — функция <tex>a\colon X\to Y</tex>, которая любому объекту <tex>x\in X</tex> ставит в соответствие идентификатор кластера <tex>y\in Y</tex>.<br />
}}<br />
Множество <tex>Y</tex> в некоторых случаях известно заранее, однако чаще ставится задача<br />
определить оптимальное число кластеров, с точки зрения того или иного ''критерия качества'' кластеризации.<br />
<br />
Кластеризация (обучение без учителя) отличается от классификации (обучения с учителем) тем,<br />
что метки объектов из обучающей выборки <tex>y_i</tex> изначально не заданы, и даже может быть неизвестно само множество <tex>Y</tex>.<br />
<br />
Решение задачи кластеризации объективно неоднозначно по ряду причин:<br />
* Не существует однозначного критерия качества кластеризации. Известен ряд алгоритмов, осуществляющих разумную кластеризацию "по построению", однако все они могут давать разные результаты. Следовательно, для определения качества кластеризации и оценки выделенных кластеров необходим эксперт предметной области;<br />
* Число кластеров, как правило, заранее не известно и выбирается по субъективным критериям. Даже если алгоритм не требует изначального знания о числе классов, конкретные реализации зачастую требуют указать этот параметр<ref>[https://scikit-learn.org/stable/modules/clustering.html scikit-learn {{---}} Clustering]</ref>;<br />
* Результат кластеризации существенно зависит от метрики. Однако существует ряд рекомендаций по выбору метрик для определенных классов задач.<ref>Cornwell, B. (2015). Linkage Criteria for Agglomerative Hierarchical Clustering. Social Sequence Analysis, 270–274</ref>.<br />
<br />
Число кластеров фактически является гиперпараметром для алгоритмов кластеризации. Подробнее про другие гиперпараметры и их настройку можно прочитать в статье<ref>Shalamov Viacheslav, Valeria Efimova, Sergey Muravyov, and Andrey Filchenkov. "Reinforcement-based Method for Simultaneous Clustering Algorithm Selection and its Hyperparameters Optimization." Procedia Computer Science 136 (2018): 144-153.</ref>.<br />
<br />
== Теорема невозможности Клейнберга ==<br />
Для формализации алгоритмов кластеризации была использована аксиоматическая теория. Клейнберг постулировал три простых свойства в качестве аксиом кластеризации и доказал теорему, связывающую эти свойства.<br />
{{Определение<br />
|definition =<br />
Алгоритм кластеризации <tex>a</tex> является '''масштабно инвариантным''' (англ. ''scale-invariant''), если для любой функции расстояния <tex>\rho</tex> и любой константы <tex>\alpha > 0</tex> результаты кластеризации с использованием расстояний <tex>\rho</tex> и <tex>\alpha\cdot\rho</tex> совпадают.<br />
}} <br />
Первая аксиома интуитивно понятна. Она требует, чтобы функция кластеризации не зависела от системы счисления функции расстояния и была нечувствительна к линейному растяжению и сжатию метрического пространства обучающей выборки.<br />
{{Определение<br />
|definition =<br />
'''Полнота''' (англ. ''Richness''). Множество результатов кластеризации алгоритма <tex>a</tex> в зависимости от изменения функции расстояния <tex>\rho</tex> должно совпадать со множеством всех возможных разбиений множества объектов <tex>X</tex>.<br />
}} <br />
Вторая аксиома утверждает, что алгоритм кластеризации должен уметь кластеризовать обучающую выборку на любое фиксированное разбиение для какой-то функции расстояния <tex>\rho</tex>.<br />
{{Определение<br />
|definition =<br />
Функция расстояния <tex>{\rho}'</tex> является '''допустимым преобразованием''' функции расстояния <tex>\rho</tex>, если<br />
#<tex>{\rho}'(x_i, x_j) \leqslant \rho(x_i, x_j)</tex>, если <tex>x_i</tex> и <tex>x_j</tex> лежат в одном кластере;<br />
#<tex>{\rho}'(x_i, x_j) \geqslant \rho(x_i, x_j)</tex>, если <tex>x_i</tex> и <tex>x_j</tex> лежат в разных кластерах.<br />
}}<br />
{{Определение<br />
|definition =<br />
Алгоритм кластеризации является '''согласованным''' (англ. ''consistent''), если результат кластеризации не изменяется после допустимого преобразования функции расстояния.<br />
}} <br />
Третья аксиома требует сохранения кластеров при уменьшении внутрикластерного расстояния и увеличении межкластерного расстояния.<br />
<br />
{| class="wikitable"<br />
| style="text-align:center; font-weight:bold;" colspan=3|Примеры преобразований с сохранением кластеров<br />
|-<br />
| style="padding:5px;" |[[Файл:cluster_0.png|300px]]<br />
| style="padding:5px;" |[[Файл:clusters_scale_inv.png|300px]]<br />
| style="padding:5px;" |[[Файл:cluster_consist.png|300px]]<br />
|-<br />
| style="text-align:center;width:305px;" | Исходное расположение объектов и их кластеризация<br />
| style="text-align:center;width:305px;" | Пример масштабной инвариантности. Уменьшен масштаб по оси ординат в два раза.<br />
| style="text-align:center;width:305px;" | Пример допустимого преобразования. Каждый объект в два раза приближен к центроиду своего класса. Внутриклассовое расстояние уменьшилось, межклассовое увеличилось.<br />
|}<br />
<br />
<br />
Исходя из этих аксиом Клейнберг сформулировал и доказал теорему:<br />
{{Теорема<br />
|author=Клейнберга<br />
|about=о невозможности<br />
|statement=Для множества объектов, состоящего из двух и более элементов, не существует алгоритма кластеризации, который был бы одновременно масштабно-инвариантным, согласованным и полным.<br />
}}<br />
Несмотря на эту теорему Клейнберг показал<ref>[https://www.cs.cornell.edu/home/kleinber/nips15.pdf Kleinberg J. An Impossibility Theorem for Clustering]</ref>, <br />
что иерархическая кластеризация по методу одиночной связи с различными критериями останова удовлетворяет любым двум из трех аксиом.<br />
<br />
== Типология задач кластеризации ==<br />
=== Типы входных данных ===<br />
* Признаковое описание объектов. Каждый объект описывается набором своих характеристик, называемых признаками (англ. ''features''). Признаки могут быть как числовыми, так и категориальными;<br />
* Матрица расстояний между объектами. Каждый объект описывается расстоянием до всех объектов из обучающей выборки.<br />
<br />
Вычисление матрицы расстояний по признаковому описанию объектов может быть выполнено бесконечным числом способов в <br />
зависимости от определения метрики между объектами. Выбор метрики зависит от обучающей выборки и поставленной задачи.<br />
<br />
=== Цели кластеризации ===<br />
* Классификация объектов. Попытка понять зависимости между объектами путем выявления их кластерной структуры. Разбиение выборки на группы схожих объектов упрощает дальнейшую обработку данных и принятие решений, позволяет применить к каждому кластеру свой метод анализа (стратегия «разделяй и властвуй»). В данном случае стремятся уменьшить число кластеров для выявления наиболее общих закономерностей;<br />
* Сжатие данных. Можно сократить размер исходной выборки, взяв один или несколько наиболее типичных представителей каждого кластера. Здесь важно наиболее точно очертить границы каждого кластера, их количество не является важным критерием;<br />
* Обнаружение новизны (обнаружение шума). Выделение объектов, которые не подходят по критериям ни в один кластер. Обнаруженные объекты в дальнейшем обрабатывают отдельно.<br />
<br />
=== Методы кластеризации ===<br />
* Графовые алгоритмы кластеризации. Наиболее примитивный класс алгоритмов. В настоящее время практически не применяется на практике;<br />
* Вероятностные алгоритмы кластеризации. Каждый объект из обучающей выборки относится к каждому из кластеров с определенной степенью вероятности:<br />
** [[EM-алгоритм]]<sup>[на 28.01.19 не создан]</sup>;<br />
* [[Иерархическая_кластеризация|Иерархические алгоритмы кластеризации]]. Упорядочивание данных путем создания иерархии вложенных кластеров;<br />
* [[K-средних|Алгоритм <tex>\mathrm{k}</tex>-средних]]<sup>[на 28.01.19 не создан]</sup> (англ. ''<tex>\mathrm{k}</tex>-means''). Итеративный алгоритм, основанный на минимизации суммарного квадратичного отклонения точек кластеров от центров этих кластеров;<br />
* Распространение похожести (англ. ''affinity propagation''). Распространяет сообщения о похожести между парами объектов для выбора типичных представителей каждого кластера;<br />
* Сдвиг среднего значения (англ. ''mean shift''). Выбирает центроиды кластеров в областях с наибольшей плотностью;<br />
* Спектральная кластеризация (англ. ''spectral clustering''). Использует собственные значения матрицы расстояний для понижения размерности перед использованием других методов кластеризации;<br />
* Основанная на плотности пространственная кластеризация для приложений с шумами (англ. ''Density-based spatial clustering of applications with noise'', ''DBSCAN''). Алгоритм группирует в один кластер точки в области с высокой плотностью. Одиноко расположенные точки помечает как шум.<br />
<br />
<br />
[[Файл:cluster_comparison.png|thumb|800px|center|<div style="text-align:center">Сравнение алгоритмов кластеризации из пакета scikit-learn<ref>[https://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html scikit-learn {{---}} Comparing different clustering algorithms on toy datasets]</ref></div>]]<br />
<br />
== Меры качества кластеризации ==<br />
Для оценки качества кластеризации задачу можно переформулировать в терминах задачи дискретной оптимизации. <br />
Необходима так сопоставить объектам из множества <tex>X</tex> метки кластеров, чтобы значение выбранного функционала качества приняло наилучшее значение. <br />
В качестве примера, стремятся достичь минимума среднего внутрикластерного расстояния <tex>F_0 = \dfrac{\sum_{i<j}{[y_i=y_j]\cdot\rho(x_i, x_j)}}{\sum_{i<j}[y_i=y_j]}</tex> или максимума среднего межкластерного расстояния <tex>F_1 = \dfrac{\sum_{i<j}{[y_i\neq y_j]\cdot\rho(x_i, x_j)}}{\sum_{i<j}[y_i\neq y_j]}</tex>.<br />
<br />
Подробнее про меры качества можно прочитать в статье [[Оценка_качества_в_задаче_кластеризации|оценка качества в задаче кластеризации]].<br />
<br />
== Применение ==<br />
=== Биология и биоинформатика ===<br />
* В области экологии кластеризация используется для выделения пространственных и временных сообществ организмов в однородных условиях;<br />
* Кластерный анализ используется для группировки схожих геномных последовательностей в семейство генов, которые являются консервативными структурами для многих организмов и могут выполнять схожие функции;<br />
* Кластеризация помогает автоматически определять генотипы по различным частям хромосом;<br />
* Алгоритмы применяются для выделения небольшого числа групп генетических вариации человеческого генома.<br />
=== Медицина ===<br />
* Используется в позитронно-эмиссионной томографии для автоматического выделения различных типов тканей на трехмерном изображении;<br />
* Применяется для выявления шаблонов устойчивости к антибиотикам; для классификации антибиотиков по типу антибактериальной активности.<br />
=== Маркетинг ===<br />
Кластеризация широко используется при изучении рынка для обработки данных, полученных из различных опросов.<br />
Может применяться для выделения типичных групп покупателей, разделения рынка для создания персонализированных предложений, разработки новых линий продукции.<br />
=== Интернет ===<br />
* Выделение групп людей на основе графа связей в социальных сетях;<br />
* Повышение релевантности ответов на поисковые запросы путем группировки веб-сайтов по смысловым значениям поискового запроса.<br />
=== Компьютерные науки ===<br />
* Кластеризация используется в сегментации изображений для определения границ и распознавания объектов;<br />
* Кластерный анализ применяется для определения образовавшихся популяционных ниш в ходе работы эволюционных алгоритмов для улучшения параметров эволюции;<br />
* Подбор рекомендаций для пользователя на основе предпочтений других пользователей в данном кластере;<br />
* Определение аномалий путем построения кластеров и выявления неклассифицированных объектов.<br />
<br />
== См. также ==<br />
* [[Оценка_качества_в_задаче_кластеризации|Оценка качества в задаче кластеризации]]<br />
* [[EM-алгоритм|EM-алгоритм]]<sup>[на 28.01.18 не создан]</sup><br />
* [[Иерархическая_кластеризация|Иерархическая кластеризация]]<br />
* [[k-средних|<tex>\mathrm{k}</tex>-средних]]<sup>[на 28.01.18 не создан]</sup><br />
<br />
== Примечания ==<br />
<references/><br />
<br />
== Источники информации ==<br />
<br />
* [https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%BD%D1%8B%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7 Википедия {{---}} Кластерный анализ]<br />
* [https://en.wikipedia.org/wiki/Cluster_analysis Wikipedia {{---}} Cluster analysis]<br />
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D0%BB%D0%B0%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F MachineLearning {{---}} Кластеризация] <br />
* [http://www.machinelearning.ru/wiki/images/c/ca/Voron-ML-Clustering.pdf К.В.Воронцов Лекции по алгоритмам кластеризации и многомерного шкалирования]<br />
* [https://www.cs.cornell.edu/home/kleinber/nips15.pdf Kleinberg J. An Impossibility Theorem for Clustering]<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Кластеризация]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D1%83%D1%81%D1%82%D0%B8%D0%BD%D0%B3,_AdaBoost&diff=69674Бустинг, AdaBoost2019-01-30T19:55:36Z<p>Dariyakovleva: </p>
<hr />
<div>==Описание==<br />
'''Бустинг''' (англ. ''boosting'') {{---}} [[Мета-обучение|мета-алгоритм машинного обучения]]. Основной идеей бустинга является комбинирование слабых функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Сильный обучающий алгоритм является классификатором, хорошо [[Корреляция случайных величин|коррелирующим]] с верной классификацией, в отличие от слабого. Наравне с бустингом в мета-обучении также рассматривают такие понятия, как [[Виды ансамблей|бэггинг]] (англ. ''bagging'') и стэкинг<ref>[https://dyakonov.org/2017/03/10/c%D1%82%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3-stacking-%D0%B8-%D0%B1%D0%BB%D0%B5%D0%BD%D0%B4%D0%B8%D0%BD%D0%B3-blending/#more-4558 Стекинг {{---}} Дьяконов Александр]</ref> (англ. ''stacking''). Бэггинг, в отличии от бустинга, использует параллельное обучение базовых классификаторов. Стэкинг же комбинирует результаты различных алгоритмов, получая тем самым более точный ответ. <br />
<br />
Одним из недостатков бустинга является то, что он может приводить к построению громоздких композиций, состоящих из сотен алгоритмов. Такие композиции исключают возможность содержательной интерпретации, требуют больших объёмов памяти для хранения базовых алгоритмов и существенных затрат времени на вычисление классификаций.<br />
<br />
==Алгоритмы бустинга==<br />
{{Определение<br />
|definition='''Композицией''' $T$ '''алгоритмов''' <tex>a_t(x) = C(b_t(x)),\ t = 1,...,T</tex> называется [[Суперпозиции|суперпозиция]] алгоритмических операторов <tex>b_t\ :\ X\to R</tex>, корректирующей операции <tex>F\ :\ R^T\to R</tex> и решающего правила <tex> C\ :\ R\to Y</tex>, где <tex>R</tex> {{---}} пространство оценок,<br><center><tex>a(x) = C(F(b_1(x),...,b_T(x))), x \in X</tex></center><br>, Алгоритмы $a_t$ называют ''базовыми алгоритмами''.}}<br />
Бустинг представляет собой композицию алгоритмов, в которых ошибки отдельных алгоритмов взаимно компенсируются. Например, в задаче классификации на два класса $Y = {-1, +1}$ в качестве пространства оценок принимают $R = \mathbb{R}$ и <tex>C(b(x)) = \textrm{sign}(b(x))</tex>. Тогда базовые алгоритмы возвращают ответы $−1, 0, +1$. Ответ $b_t(x) = 0$ означает, что базовый алгоритм $b_t$ отказывается от классификации объекта $x$, и ответ $b_t(x)$ не учитывается в композиции. Получаем искомую композицию:<br />
<center><tex>a(x) = C(F(b_1(x),...,b_T(x))) = \textrm{sign}\left(\sum\limits_{t=1}^T \alpha_t b_t(x)\right),\ x\in X</tex></center>,<br />
<br />
Большая часть алгоритмов бустинга основывается на итеративном обучении слабых классификаторов с дальнейшей сборкой их в сильный классификатор. Когда они добавляются, им обычно приписываются веса, обычно связанные с [[Общие понятия|точностью обучения]]. После добавления слабого классификатора, веса пересчитываются ('''«пересчёт весовых коэффициентов»'''). Неверно классифицированные входные данные получают больший вес, а правильно классифицированные экземпляры теряют вес. Таким образом, дальнейшее слабое обучение фокусируется на примерах, где предыдущие слабые обучения дали ошибочную классификацию.<br />
<br />
Основное расхождение между многими алгоритмами бустинга заключается в методах определения весовых коэффициентов точек [[Общие понятия|тренировочных данных]] и гипотез. Первым алгоритмом, который смог адаптироваться к слабому обучению был '''AdaBoost'''<ref>[http://rob.schapire.net/papers/explaining-adaboost.pdf Explaining AdaBoost {{---}} Robert E. Schapire]</ref> (сокр. ''Adaptive Boosting''), предложенный Шапире и Фройндом.<br />
<br />
Алгоритмы бустинга могут использовать выпуклую или невыпуклую функцию потерь. Алгоритмы с выпуклой функцией, такие как AdaBoost и LogitBoost<ref>[https://en.wikipedia.org/wiki/LogitBoost Wikipedia {{---}} LogitBoost]</ref>, могут некорректно классифицировать из-за случайного шума, так как не могут обучить базовым и поддающимся научению комбинациям слабых гипотез. Алгоритмы бустинга, основанные на невыпуклой функции потерь, такие как BrownBoost<ref>[https://ru.wikipedia.org/wiki/BrownBoost Википедия {{---}} BrownBoost]</ref>, позволяют избежать переобучения на данных с большим количеством "шума", откидывая зашумленные элементы.<br />
<br />
==Прикладное использование алгоритмов бустинга==<br />
===Задача классификации объектов===<br />
Если даны изображения, содержащие различные известные в мире объекты, классификатор может быть обучен на основе них для автоматической классификации объектов в будущих неизвестных изображениях. Простые классификаторы, построенные на основе некоторых признаков изображения объекта, обычно оказываются малоэффективными в классификации. Использование методов бустинга для классификации объектов {{---}} путь объединения слабых классификаторов специальным образом для улучшения общей возможности классификации.<br />
<br />
Классификация признаков является типичной задачей компьютерного зрения, где определяется, содержит ли изображение некоторую категорию объектов или нет. Идея тесно связана с распознаванием, идентификацией и обнаружением. Классификация по обнаружению объекта обычно содержит выделение [[Общие понятия|признаков]], обучение классификатора и применение классификатора к новым данным. Есть много способов представления категории объектов, например по анализу формы, с помощью модели '''«мешок слов»''', с помощью локальных описателей, таких как '''SIFT'''<ref>[https://en.wikipedia.org/wiki/Scale-invariant_feature_transform Wikipedia {{---}} Scale-invariant feature transform]</ref>, и так далее. Примерами классификаторов с учителем служат наивные [[Байесовская классификация|байесовские классификаторы]]<sup>[на 28.01.19 не создан]</sup>, [[Метод опорных векторов (SVM)|методы опорных векторов]]<sup>[на 28.01.19 не создан]</sup>, смесь гауссиан и [[Нейронные сети, перцептрон|нейронные сети]]. Однако исследования показали, что категории объектов и их положение в изображениях могут быть обнаружены также с помощью обучения без учителя.<br />
<br />
===Задача ранжирования выдачи поисковых систем===<br />
Благодаря AdaBoost в мире появился [[CatBoost|градиентный бустинг]] (англ. ''gradient boosting'') или GBM. Задачу ранжирования выдачи поисковых запросов рассмотрели с точки зрения функции потерь, которая штрафует за ошибки в порядке выдачи, поэтому было удобно внедрить GBM в ранжирование.<br />
<br />
==AdaBoost==<br />
===Описание===<br />
Алгоритм может использоваться в сочетании с несколькими алгоритмами классификации для улучшения их эффективности. Алгоритм усиливает классификаторы, объединяя их в «комитет». AdaBoost является адаптивным в том смысле, что каждый следующий комитет классификаторов строится по объектам, неверно классифицированным предыдущими комитетами. AdaBoost чувствителен к шуму в данных и выбросам. Однако он менее подвержен переобучению по сравнению с другими алгоритмами машинного обучения.<br />
<br />
AdaBoost вызывает слабые классификаторы <tex>h_i^t</tex> в цикле <tex>t = 1,...,T</tex>. После каждого вызова обновляется распределение весов <tex>D_t</tex>, которые отвечают важности каждого из объектов обучающего множества для классификации. На каждой итерации веса каждого неверно классифицированного объекта возрастают, таким образом новый комитет классификаторов «фокусирует своё внимание» на этих объектах.<br />
<br />
===Описание алгоритма===<br />
<br />
<font color=green>//<tex>x_i \in X, y_i \in Y = \{-1,+1\}, size(x) = size(y) = m</tex></font><br />
'''function''' AdaBoost($X$, $Y$, $m$):<br />
<font color=green>//Инициализируем</font><br />
'''for''' i = 1..m '''do''':<br />
<tex>D_i^1 = \frac{1}{m}</tex><br />
'''end''' '''for'''<br />
<br />
'''for''' t = 1..T '''do''':<br />
<tex>h_t = \arg \min\limits_{h_j \in \mathcal{H}} \epsilon_j = \sum\limits_{i=1}^{m} D_i^t〚y_i\neq h_j(x_i)〛</tex> <font color=green>//$\epsilon$ {{---}} Взвешенная ошибка классификации, классификатор <tex>h_t:X\to \{-1,+1\}</tex></font><br />
<tex>\alpha_t = \frac{1}{2}\ln\frac{1-\epsilon_t}{\epsilon_t}</tex><br />
'''for''' i = 1..m '''do''':<br />
<font color=green>//<tex>Z_t</tex> {{---}} нормализующий параметр, выбранный так, чтобы <tex>D^{t+1}</tex> являлось распределением вероятностей, то есть <tex>\sum\limits_{i-1}^{m} D_i^{t+1} = 1</tex>, для <tex>t=1,...,T</tex></font> <br />
<tex>D_i^{t+1} = \dfrac{D_i^t \textrm{exp}(-\alpha_t y_i h_t(x_i))}{Z_t}</tex> <br />
'''end''' '''for'''<br />
'''end''' '''for'''<br />
<tex>H(x) = \textrm{sign}\left(\sum\limits_{t=1}^{T} \alpha_t h_t(x)\right)</tex> <font color=green>//$H(x)$ {{---}} результирующий классификатор</font><br />
'''return''' $H$<br />
Выражение для обновления распределения <tex>D^t</tex> должно быть сконструировано таким образом, чтобы выполнялось условие:<br />
<center><tex>\exp^{\alpha_t y_i h_t(x_i)} \begin{cases}<1,\ y(i) = h_t(x_i) \\ >1,\ y(i) \neq h_t(x_i)\end{cases}</tex></center>,<br />
<br />
Таким образом, после выбора оптимального классификатора <tex>h_t</tex> для распределения <tex>D^t</tex>, объекты <tex>x_i</tex>, которые классификатор <tex>h_t</tex> идентифицирует корректно, имеют веса меньшие, чем те, которые идентифицируются некорректно. Следовательно, когда алгоритм тестирует классификаторы на распределении <tex>D^{t+1}</tex>, он будет выбирать классификатор, который лучше идентифицирует объекты неверно распознаваемые предыдущим классификатором.<br />
<br />
===Пример работы===<br />
Рассмотрим набор данных, которые пометим как $-$ и $+$.<br />
[[Файл:Adaboost1.jpg|600px|thumb|center|Результат после первой итерации]]<br />
Для всех ошибочно классифицированных объектов увеличим веса, а для верно классифицированных уменьшим<br />
[[Файл:Adaboost2.jpg|1000px|thumb|center|Результат после пересчета весов и второй итерации]]<br />
Рассмотрим результат после $2$-х итераций:<br />
[[Файл:Adaboost_result12.jpg|1000px|thumb|center|Итоговый результат после $2$-х итераций]]<br />
Как видно из последнего изображения, все, что находиться в "цветной" зоне, мы можем однозначно классифицировать, но тогда у нас появляются ошибки и "белые" зоны, которые мы не можем однозначно классифицировать. Рассмотрим алгоритм после $30$-ти итераций:<br />
[[Файл:Adaboost_resultfinal.jpg|300px|thumb|center|Результат работы алгоритма после $30$-ти итераций]]<br />
Теперь у нас все объекты классифицируются верно и число ошибок на выборке равно нулю.<br />
<br />
===Достоинства и недостатки===<br />
'''Достоинства:'''<br />
# Простота реализации;<br />
# Хорошая обобщающая способность. В реальных задачах удаётся строить композиции, превосходящие по качеству базовые алгоритмы. Обобщающая способность может улучшаться по мере увеличения числа базовых алгоритмов;<br />
# Время построения композиции практически полностью определяется временем обучения базовых алгоритмов;<br />
# Возможность идентифицировать выбросы. Это наиболее «трудные» объекты $x_i$, для которых в процессе наращивания композиции веса $w_i$ принимают наибольшие значения.<br />
'''Недостатки:'''<br />
# Склонен к переобучению при наличии значительного уровня шума в данных;<br />
# Требует достаточно длинных обучающих выборок. Другие методы линейной коррекции, в частности, бэггинг, способны строить алгоритмы сопоставимого качества по меньшим выборкам данных.<br />
<br />
===Пример кода на python для scikit-learn===<br />
Классификатор sklearn.ensemble.'''AdaBoostClassifier'''<ref>[https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html Документация AdaBoostClassifier]</ref> имеет 5 параметров: '''base_estimator''', '''n_estimators''', '''learning_rate''', '''algorithm''', '''random_state'''.<br />
Наиболее важными являются: <br />
# '''base_estimator''' {{---}} базовый алгоритм. По умолчанию используется DecisionTreeClassifier(max_depth=1);<br />
# '''n_estimators''' {{---}} максимальное количество оценок, после которого бустинг прекращается. Если произойдет полное совпадение, то закончится раньше;<br />
# '''learning_rate''' {{---}} вклад каждой модели в весовые коэффициенты и значение по умолчанию равно $1$. Снижение этого параметра будет означать, что весовые коэффициенты буду увеличиваться или уменьшаться в небольшой степени, вынуждая модель дольше обучаться (но иногда повышается производительность).<br />
<br />
'''from''' sklearn.ensemble '''import''' AdaBoostClassifier<br />
'''from''' sklearn '''import''' datasets<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
'''from''' sklearn '''import''' metrics<br />
<br />
iris = datasets.'''load_iris()'''<br />
<br />
X = iris.data<br />
y = iris.target<br />
<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')<br />
<br />
abc = AdaBoostClassifier(n_estimators='''50''', learning_rate='''1''')<br />
<br />
model = abc.'''fit'''(X_train, y_train)<br />
<br />
y_pred = model.'''predict'''(X_test)<br />
<br />
'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))<br />
<br />
Accuracy: 0.8888888888888888<br />
<br />
Теперь рассмотрим алгоритм с SVC в качестве базы:<br />
'''from''' sklearn.svm '''import''' SVC<br />
<br />
svc=SVC(probability='''True''', kernel=''''linear'''')<br />
<br />
abc = AdaBoostClassifier(base_estimator='''svc''', n_estimators='''50''', learning_rate='''1''')<br />
<br />
model = abc.'''fit'''(X_train, y_train)<br />
<br />
y_pred = model.'''predict'''(X_test)<br />
<br />
'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))<br />
<br />
Accuracy: 0.9555555555555556<br />
<br />
===Пример на языке Scala===<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.adaboost<ref>[https://haifengl.github.io/smile/classification.html#adaboost Smile, AdaBoost]</ref>:<br />
'''import '''smile.classification._<br />
'''import '''smile.data._<br />
'''import '''smile.plot._<br />
'''import '''smile.read<br />
'''import '''smile.validation.FMeasure<br />
<br />
'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = iris.x()<br />
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)<br />
'''val '''ada: AdaBoost = adaboost(x, y, ntrees = 500, maxNodes = 2)<br />
'''val '''predictions: Array['''Int'''] = x.map(ada.predict)<br />
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)<br />
plot(x, y, ada)<br />
<br />
== См. также ==<br />
*[[Метод опорных векторов (SVM)|Метод опорных векторов]]<sup>[на 28.01.19 не создан]</sup><br />
*[[Байесовская классификация|Байесовская классификация]]<sup>[на 28.01.19 не создан]</sup><br />
*[[Мета-обучение|Мета-обучение]]<br />
*[[Нейронные сети, перцептрон|Нейронные сети]]<br />
*[[Оценка качества в задаче кластеризации|Оценка качества в задаче кластеризации]]<br />
*[[CatBoost|CatBoost]]<br />
<br />
== Примечания==<br />
<references /><br />
<br />
== Источники информации ==<br />
# [http://www.machinelearning.ru/wiki/index.php?title=AdaBoost AdaBoost] {{---}} статья на machinelearning.ru<br />
# [http://cmp.felk.cvut.cz/~sochmj1/adaboost_talk.pdf AdaBoost] {{---}} презентация по AdaBoost<br />
# [https://ru.coursera.org/lecture/ml-classification/example-of-adaboost-in-action-um0cX Example of AdaBoost in action] {{---}} презентация на coursera.org<br />
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2) Курс лекций по машинному обучению] {{---}} Воронцов К.В.<br />
[[Категория: Автоматическое машинное обучение]]<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%B5%D0%B3%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%86%D0%B8%D1%8F_%D0%B8%D0%B7%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9&diff=69673Сегментация изображений2019-01-30T19:51:39Z<p>Dariyakovleva: </p>
<hr />
<div><br />
'''Сегментация изображения''' {{---}} задача поиска групп пикселей, каждая из которых характеризует один смысловой объект. В статистике эта проблема известна как кластерный анализ и является широко изученной областью с сотнями различных алгоритмов. В компьютерном зрении сегментация изображения является одной из старейших и широко изучаемых проблем.<br />
<br />
В более ранних техниках используется ''расщепление'' и ''слияние'' регионов, что соответствует ''разделительным'' и ''агломерационным'' алгоритмам в литературе по [[Кластеризация|кластеризации]]. Современные алгоритмы чаще оптимизируют некоторые глобальные критерии, такие как внутрирегиональная согласованность и межрегиональные длины границ.<br />
<br />
Ниже будут рассмотрены два алгоритма {{---}} графо-ориентированная сегментация и метод нормализованных срезов. Первый из них является базовым алгоритмом сегментации, который прост и понятен в реализации, но медленный и результаты недостаточно хороши. Второй алгоритм является продвинутой версией первого со множеством эвристик. Что отражается, как на производительности, так и на результатах. <br />
<br />
== Графо-ориентированная сегментация (англ. Graph-based segmentation) == <br />
<br />
Это алгоритм объединения, который использует относительные различия между регионами, чтобы определить, какие из них следует объединить. Кроме того, он доказуемо оптимизирует глобальную метрику группировки. Введем ''меру отличия'' одного пикселя от другого <tex>w(e)</tex>, где <tex>e = (v_1, v_2)</tex> {{---}} пара соседних по стороне или по углу пикселей. ''Мера отличия'' может показывать, например, разницу цветовой интенсивности между соседями, которых у пикселя максимум восемь. <br />
<br />
Для любого региона ''R'', его внутренняя разница определяется как наибольшая ''мера отличия'' в минимальном остовном дереве региона,<br />
<br><center><tex>Int(R) = \displaystyle\min_{e \in MST(R)} w(e)</tex></center>,<br />
<br />
Для любых двух соседних областей, по крайней мере, с одним смежным ребром, соединяющим их вершины, разность между этими регионами определяется как ребро минимального веса, соединяющее эти два региона,<br />
<br><center><tex>Dif(R_1, R_2) = \displaystyle\min_{e = (v_1, v_2) | v_1 \in R_1, v_2 \in R_2} w(e)</tex></center>,<br />
<br />
Алгоритм объединяет любые две соседние области, разница которых меньше минимальной внутренней разности этих двух областей, <br />
<br><center><tex>MInt(R_1, R_2) = \min(Int(R_1) + \tau(R_1), Int(R_2) +\tau(R_2)),</tex></center><br />
где <tex>\tau(R)</tex> {{---}} эвристический штраф по региону, который был установлен <tex>k / |R|</tex>, однако, он может быть установлен как любая специфическая для области применения мера.<br />
<br />
Объединяя области в порядке убывания разделяющих их ребер (можно эффективно оценить с использованием алгоритма минимального остовного дерева Крускала), они доказуемо дают сегментацию. Причем такую, в которой присутствуют как области, которые могли бы быть объединены, так и те, которые могут быть разделены, но в небольших количествах. Для окрестностей пикселей фиксированного размера время работы этого алгоритма составляет <tex>O (N \log N)</tex>, где <tex>N</tex> {{---}} количество пикселей изображения, что делает его одним из самых быстрых алгоритмов сегментации.<br />
<br><center>[[Файл:beforeAfterGraphBased.png|800px|thumb|center|Источник: Felzenszwalb, P. F. and Huttenlocher, D. P. «Efficient graph-based image segmentation.»[http://people.cs.uchicago.edu/~pff/papers/seg-ijcv.pdf]]]</center><br />
<br>На рисунке слева {{---}} исходное изображение, справа {{---}} сегментированное после применения данного алгоритма.<br />
<br />
== Метод нормализованных срезов (англ. Normalized cuts) ==<br />
<br />
Mетод нормализованных срезов, исследует сходство между соседними пикселями и пытается разделить их на группы, которые в свою очередь связаны слабо. <br />
Рассмотрим простой пример.<br />
[[Файл:graphNormalizedCut.png|800px|thumb|center|Источник: Richard Szeliski «Computer Vision: Algorithms and Applications.»[http://szeliski.org/Book/drafts/SzeliskiBook_20100903_draft.pdf]]]<br />
<br>Все пиксели в группе A имеют высокое сходство, показанное в виде толстых красных линий, как и пиксели в группе B. Соединения между этими двумя группами, показанные в виде более тонких синих линий, намного слабее. ''Нормализованный разрез'' между двумя группами, показанный пунктирной линией, разделяет их на два кластера.<br />
<br />
Разрез между двумя группами A и B определяется как сумма всех взвешенных весов,<br />
<br><center><tex>cut(A, B) = \displaystyle\sum_{i \in A, j \in B}w_{ij},</tex></center><br />
где веса между двумя пикселями <tex>i</tex> и <tex>j</tex> соответствуют их сходству. Однако использование минимального среза в качестве критерия сегментации не приводит к разумным кластерам, поскольку наименьшие срезы обычно предусматривают выделение одного пикселя.<br />
<br />
Лучшей мерой сегментации является нормализованный срез, который определяется как<br />
<br><center><tex>Ncut(A,B)=\frac{cut(A,B)}{assoc(A, V)}+\frac{cut(A,B)}{assoc(B,V)},</tex></center><br />
где <tex>assoc(A,A)=\sum_{i \in A, j \in A}w_{ij}</tex> это ''ассоциация'' (сумма всех весов) в кластере и <tex>assoc(A,V)=assoc(A,A)+cut(A,B)</tex> это сумма всех весов ассоциированных с <tex>А</tex>. <br />
<br>Нормализованные разрезы могут быть довольно медленными, поскольку это требует решения больших разреженных задач. Однако существует способ ускорить вычисление нормализованных разрезов, используя подход, основанный на алгебраической сетке. Можно выбирать меньшее количество переменных, чтобы оставшиеся переменные более нижнего уровня были ''сильно связаны'' по крайней мере с одной переменной грубого уровня. Подмножество <tex>C \subset V</tex> считается ''сильно связанным'', если выполняется<br />
<br><center><tex>\frac{\sum_{j \in C}w_{ij}}{\sum_{j \in V}w_{ij}} > \phi, [*]</tex></center> <br />
обычно <tex>\phi = 0.2.</tex> Данный рисунок схематично показывает этот процесс.<br />
<br />
[[Файл:grephEdges.png|880px|thumb|center|''на первом изображении'' {{---}} исходная пиксельная сетка черно-белого изображения; ''на втором'' {{---}} межпиксельные связи, где более толстые линии указывают на более сильные связи; ''на третьем'' {{---}} сетка после одного уровня огрубления, когда каждый исходный пиксель сильно связан с одним из узлов грубого уровня; ''на четвертом'' {{---}} после двух уровней огрубления. Источник: Shaw, D. and Barnes, N. «Perspective rectangle detection. In Workshop on Applications of Computer Vision.» [https://www.researchgate.net/publication/6975028_Hierarchy_and_adaptivity_in_segmenting_visual_scenes]]]<br />
<br />
Каждый пиксель на первом изображении соответствует вершине графа на втором изображении, которая связана с каждым из ее четырех соседей в соответствии с их сходством по уровню яркости. Цель состоит в том, чтобы «разрезать» этот граф на части. Далее можно найти ''сильно связное'' подмножество, которое минимизирует отношение <tex>[*]</tex>. Но несмотря на свою концептуальную значимость, минимизация этого ''нормализованного разреза'' является вычислительно непомерной, а стоимость увеличивается экспоненциально с размером изображения. Приближения к оптимальному разрезу могут быть получены с использованием спектральных методов, при этом наиболее эффективное на сегодняшний день приближение имеет вычислительную стоимость, пропорциональную <tex>n^{\frac{2}{3}}</tex>, где <tex>n</tex> {{---}} количество пикселей. Эта сверхлинейная сложность может быть чрезвычайно полезна, когда дело касается очень больших изображений. <br />
<br />
Так как количество вершин графа на втором изображении велико и работать с каждым из них чрезвычайно дорого, необходимо выделить подмножество вершин-предводителей для каждого из подмножеств и далее работать уже с ними. Мы начнем с выбора примерно половины пикселей в качестве представителей, которые назовем ''начальными числами'': они выбираются таким образом, чтобы каждый пиксель в исходном изображении был ''сильно связан'' по крайней мере с одним соседним с ним ''начальным числом'' (см. третье изображение). Далее процесс продолжается рекурсивно (см. четвертое изображение), количество вершин на каждом новом более грубом уровне уменьшается. Значения узлов более нижнего уровня вычисляются путем интерполяции родительских значений и сопоставления значений <tex> \epsilon = 0,1</tex> в пределах от 0 и 1 до Boolean значений. Выраженные сегменты появляются на соответствующем уровне как узлы, которые слабо связаны со своими соседями. Следовательно, задача минимизации упрощается до поиска вершин-предводителей на всех уровнях. <br />
<br />
Результат работы данного алгоритма:<br />
[[Файл:watches.png|880px|thumb|center|Источник: Shaw, D. and Barnes, N. «Perspective rectangle detection. In Workshop on Applications of Computer Vision.» [https://www.researchgate.net/publication/6975028_Hierarchy_and_adaptivity_in_segmenting_visual_scenes]]]<br />
<br />
== См. также ==<br />
<br />
[[Задача нахождения объектов на изображении]]<br />
<br />
== Источники информации ==<br />
<br />
* Richard Szeliski «Computer Vision: Algorithms and Applications.» - «Springer», 2010. - С. 286-300<br />
* Felzenszwalb, P. F. and Huttenlocher, D. P. (2004b). Efficient graph-based image segmentation.[http://people.cs.uchicago.edu/~pff/papers/seg-ijcv.pdf]<br />
* Shaw, D. and Barnes, N. (2006). Perspective rectangle detection. In Workshop on Applications of Computer Vision at ECCV’2006.<br />
* Brandt, A. (1986). Algebraic multigrid theory: The symmetric case. Applied Mathematics and Computation, 19(1-4):23–56.<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Компьютерное зрение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8&diff=69672Уменьшение размерности2019-01-30T19:47:41Z<p>Dariyakovleva: </p>
<hr />
<div>Под '''уменьшением размерности''' (англ. ''dimensionality reduction'') в машинном обучении подразумевается уменьшение числа признаков набора данных. Наличие в нем признаков избыточных, неинформативных или слабо информативных может понизить эффективность модели, а после такого преобразования она упрощается, и соответственно уменьшается размер набора данных в памяти и ускоряется работа алгоритмов ML на нем. Уменьшение размерности может быть осуществлено методами выбора признаков (англ. ''feature selection'') или выделения признаков (англ. ''feature extraction'').<br />
==Выбор признаков==<br />
Методы '''выбора признаков''' оставляют некоторое подмножество исходного набора признаков, избавляясь от признаков избыточных и слабо информативных. Основные преимущества этого класса алгоритмов:<br />
*Уменьшение вероятности [[переобучение|переобучения]];<br />
*Увеличение точности предсказания модели;<br />
*Сокращение времени обучения;<br />
*Увеличивается семантическое понимание модели.<br />
<br />
Все методы выбора признаков можно разделить на 5 типов, которые отличаются алгоритмами выбора лишних признаков.<br />
===Фильтры===<br />
'''Фильтры''' (англ. ''filter methods'') измеряют релевантность признаков на основе функции $\mu$, и затем решают по правилу $\kappa$, какие признаки оставить в результирующем множестве.<br />
<br />
Фильтры могут быть:<br />
*Одномерные (англ. ''univariate'') {{---}} функция $\mu$ определяет релевантность одного признака по отношению к выходным меткам. В таком случае обычно измеряют "качество" каждого признака и удаляют худшие;<br />
*Многомерные (англ. ''multivariate'') {{---}} функция $\mu$ определяет релевантность некоторого подмножества исходного множества признаков относительно выходных меток.<br />
<br />
Распространенными вариантами для $\mu$ являются:<br />
*Коэффициент ранговой корреляции Спирмена <ref>[https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient Определение коэффициента ранговой корреляции Спирмена]</ref>(англ. ''Spearman's rank correlation coefficient''): $p(x, y)=\displaystyle \frac{\sum_{i, j}(x_{ij}-\bar{x_j})(y_i-\bar{y})}{\sqrt{\sum_{i, j}(x_{ij}-\bar{x_j})^2\sum_i(y_i-\bar{y})^2}}$;<br />
*Information gain<ref>[https://en.wikipedia.org/wiki/Information_gain_in_decision_trees Определение information gain]</ref>: $IG(x, y)=\displaystyle -\sum_{i=1}^kp(c_i)\log_2{(p(c_i))}+\sum_{i=1}^{n}p(t_i)\sum_{j=1}^kp(c_j|t_i)log_2{(p(c_j|t_i))}$, и другие.<br />
<br />
Преимуществом группы фильтров является простота вычисления релевантности признаков в наборе данных, но недостатком в таком подходе является игнорирование возможных зависимостей между признаками.<br />
===Оберточные методы===<br />
[[File:Feature_selection_wrapper_rus.png|450px|thumb|right|Процесс работы оберточных методов]]<br />
'''Оберточные методы''' (англ. ''wrapper methods'') находят подмножество искомых признаков последовательно, используя некоторый классификатор как источник оценки качества выбранных признаков, т.е. этот процесс является циклическим и продолжается до тех пор, пока не будут достигнуты заданные условия останова. Оберточные методы учитывают зависимости между признаками, что является преимуществом по сравнению с фильтрами, к тому же показывают большую точность, но вычисления занимают длительное время, и повышается риск [[переобучение|переобучения]]. <br />
<br />
Существует несколько типов оберточных методов: детерминированные, которые изменяют множество признаков по определенному правилу, а также рандомизированные, которые используют генетические алгоритмы для выбора искомого подмножества признаков. Среди детерминированных алгоритмов самыми простыми являются:<br />
*SFS (Sequential Forward Selection) {{---}} жадный алгоритм, который начинает с пустого множества признаков, на каждом шаге добавляя лучший из еще не выбранных признаков в результирующее множество;<br />
*SBS (Sequential Backward Selection) {{---}} алгоритм обратный SFS, который начинает с изначального множества признаков, и удаляет по одному или несколько худших признаков на каждом шаге.<br />
<br />
Популярным оберточным методом является SVM-RFE (SVM-based Recursive Feature Elimination), который иногда также обозначается как встроенный <ref>[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117/ C. Embedded method]</ref>. Этот метод использует как классификатор [[Метод опорных векторов (SVM)| SVM]]<sup>[на 28.01.19 не создан]</sup> и работает итеративно: начиная с полного множества признаков обучает классификатор, ранжирует признаки по весам, которые им присвоил классификатор, убирает какое-то число признаков и повторяет процесс с оставшегося подмножества фичей, если не было достигнуто их требуемое количество. Таким образом, этот метод очень похож на встроенный, потому что непосредственно использует знание того, как устроен классификатор.<br />
<br />
===Встроенные методы===<br />
[[File:Feature_selection_embedded_rus.png|450px|thumb|right|Процесс работы встроенных методов]]<br />
Группа '''встроенных методов''' (англ. ''embedded methods'') очень похожа на оберточные методы, но для выбора признаков используется непосредственно структуру некоторого классификатора. В оберточных методах классификатор служит только для оценки работы на данном множестве признаков, тогда как встроенные методы используют какую-то информацию о признаках, которую классификаторы присваивают во время обучения. <br />
<br />
Одним из примеров встроенного метода является реализация на [[Дерево решений и случайный лес| случайном лесе]]: каждому дереву на вход подаются случайное подмножество данных из датасета с каким-то случайным набор признаков, в процессе обучения каждое из деревьев решений производит "голосование" за релевантность его признаков, эти данные агрегируются, и на выходе получаются значения важности каждого признака набора данных. Дальнейший выбор нужных нам признаков уже зависит от выбранного критерия отбора.<br />
<br />
Встроенные методы используют преимущества оберточных методов и являются более эффективными, при этом на отбор тратится меньше времени, уменьшается риск [[переобучение|переобучения]], но т.к. полученный набор признаков был отобран на основе знаний о классификаторе, то есть вероятность, что для другого классификатора это множество признаков уже не будет настолько же релевантным.<br />
<br />
===Другие методы===<br />
[[File:Feature_selection_ensemble_rus.png|thumb|Один из примеров процесса работы ансамблевых методов]]<br />
Есть и другие методы выбора признаков: '''гибридные''' (англ. ''hybrid methods'') и '''ансамблевые''' (англ. ''ensemble methods''). '''Гибридные методы''' комбинируют несколько разных методов выбора признаков, например, некоторое множество фильтров, а потом запускают оберточный или встроенный метод. Таким образом, гибридные методы сочетают в себе преимущества сразу нескольких методов, и на практике повышают эффективность выбора признаков.<br />
<br />
'''Ансамблевые методы''' применяются больше для наборов данных с очень большим числом признаков. В данном подходе для начального множества признаков создается несколько подмножеств признаков, и эти группы каким-то образом объединяются, чтобы получить набор самых релевантных признаков. Это довольно гибкая группа методов, т.к. для нее можно применять различные способы выбора признаков и объединения их подмножеств.<br />
<br />
<div style="clear:{{{1|both}}};"></div><br />
<br />
===Примеры кода scikit-learn===<br />
Пример кода, реализующего функцию оценки фильтра на основе коэффициента ранговой корреляции:<br />
# Импорт библиотек<br />
import pandas as pd<br />
import numpy as np<br />
<br />
# Вспомогательная функция для расчета корреляции<br />
def correlation(X, Y):<br />
return np.cov(X, Y) / np.sqrt(np.var(X) * np.var(Y))<br />
<br />
# Сам фильтр на основе метрики ранговой корреляции<br />
# Аргументы X -- значения объектов датасета для какой-то фичи, Y -- метки этих объектов<br />
def measure_spearmans(X, Y):<br />
xr = pd.Series(X).rank()<br />
yr = pd.Series(Y).rank()<br />
return correlation(xr, yr)<br />
<br />
Пример кода, реализующего SVM-RFE wrapper:<br />
# Импорт библиотек<br />
import numpy as np<br />
import pandas as pd<br />
from sklearn import svm<br />
<br />
# X -- наш датасет, Y -- массив меток<br />
# N -- число признаков, которые хотим оставить, step -- сколько фичей удаляется на каждой итерации<br />
# Возвращает массив из булевых переменных размерностью 1x[число признаков], показывающий, отбрасываем признак или нет<br />
def RFE(X, Y, N, step = 10):<br />
# cache_size нужен, если набор данных большой, иначе можно опустить<br />
clfRFE = svm.SVC(kernel='linear', cache_size=1024)<br />
featureCount = X.shape[1]<br />
featureList = np.arange(0, featureCount )<br />
included = np.full(featureCount, True)<br />
curCount = featureCount<br />
while curCount > N:<br />
actualFeatures = featureList[included]<br />
Xnew = X[:, actualFeatures]<br />
<br />
clfRFE.fit(Xnew, Y)<br />
curStep = min(step, curCount - N)<br />
elim = np.argsort(np.abs(clfRFE.coef_[0]))[:curStep]<br />
included[actualFeatures[elim]] = False<br />
curCount -= curStep<br />
return included<br />
==Выделение признаков==<br />
Другим способом уменьшить размерность входных данных является выделение признаков. Эти методы каким-то образом составляют из уже исходных признаков новые, все также полностью описывающие пространство набора данных, но уменьшая его размерность и теряя в репрезентативности данных, т.к. становится непонятно, за что отвечают новые признаки.<br />
Все методы feature extraction можно разделить на '''линейные''' и '''нелинейные'''.<br />
<br />
Одним из самых известных методов '''линейного''' выделения признаков является [[Метод главных компонент (PCA)| PCA]]<sup>[на 28.01.19 не создан]</sup> (Principal Component Analysis, рус. ''метод главных компонент''). Основной идеей этого метода является поиск такой гиперплоскости, на которую при ортогональной проекции всех признаков максимизируется дисперсия. Данное преобразование может быть произведено с помощью сингулярного разложения матриц и создает проекцию только на линейные многомерные плоскости, поэтому и метод находится в категории линейных.<br />
<br />
К '''нелинейным''' методам, например, могут быть отнесены методы отображающие исходное пространство признаков на нелинейные поверхности или топологические многообразия. Одним из таких алгоритмов является [[Стохастическое вложение соседей с t-распределением |t-SNE]]<sup>[на 28.01.19 не создан]</sup> (t-distributed Stochastic Neighbor Embedding, рус. ''стохастическое вложение соседей с t-распределением''). Данный метод состоит из двух шагов: изначально строится распределение вероятностей по всем парам точек набора данных, каждая условная вероятность $p_{j|i}$ которого означает насколько точка $X_j$ близка к точке $X_i$ при гауссовом распределении вокруг $X_i$. Данное распределение как метрику похожести использует евклидово расстояние. Алгоритм старается получить отображение из точек размерности $\mathbb{R}^k$ в меньшую размерность $\mathbb{R}^d$, для этого вводится еще одно распределение, описывающее насколько точки из нового пространства похожи друг на друга, но используя при этом t-распределение Стьюдента с одной степенью свободы. Как метрику похожести двух распределений используется дивергенция Кульбака-Лейблера<ref>[https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence Дивергенция Кульбака-Лейблера]</ref>, и чтобы найти точки новой размерности $d$ запускается градиентный спуск для минимизации этой величины. <br />
===Пример кода scikit-learn===<br />
Пример выделения признаков с помощью PCA в scikit-learn:<br />
# Импорт библиотек<br />
from sklearn.decomposition import PCA<br />
from sklearn.model_selection import train_test_split<br />
<br />
X = ... # загрузка X<br />
Y = ... # загрузка Y<br />
# Разделение данных на train и test<br />
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y)<br />
<br />
clf = ... # берем какой-то классификатор<br />
# Обучаем PCA для выделения 5 признаков<br />
pca = PCA(n_components=5)<br />
pca.fit(Xtrain)<br />
# Изменяем наши наборы данных под выбранные признаки<br />
Xtrain = pca.transform(Xtrain)<br />
Xtest = pca.transform(Xtest)<br />
# Обучаем классификатор и проверяем точность его работы<br />
clf.fit(Xtrain, Ytrain)<br />
print ("Score: %.6f" % clf.score(Xtest, Ytest))<br />
<br />
===Пример на языке Scala===<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример уменьшение размерности используя smile.feature.GAFeatureSelection<ref>[https://haifengl.github.io/smile/feature.html#genetic-algorithm-feature-selection Smile, Genetic Algorithm Based Feature Selection]</ref>:<br />
'''import '''smile.classification._<br />
'''import '''smile.data._<br />
'''import '''smile.feature.GAFeatureSelection<br />
'''import '''smile.read<br />
'''import '''smile.validation.Accuracy<br />
<br />
<span style="color:#3D9970>// Загрузка данных</span><br />
'''val '''data = read.arff("data/weka/segment-test.arff", 19)<br />
'''val '''(x, y) = data.unzipInt<br />
'''val '''trainer = '''new '''GradientTreeBoost.Trainer(100)<br />
'''val '''measure = '''new '''Accuracy<br />
<span style="color:#3D9970>// Cоздание генетического алгоритма и его настройка.</span><br />
'''val '''selector = '''new '''GAFeatureSelection<br />
<span style="color:#3D9970>// Размер популяции - 50, количество поколений - 20 </span><br />
<span style="color:#3D9970>// Каждая возращаемая BitString содержит фичи и их качество.</span><br />
'''val '''result = selector.learn(50, 20, trainer, measure, x, y, 5)<br />
result.foreach { bits =><br />
print(100*bits.fitness)<br />
println(bits.bits.mkString(" "))<br />
}<br />
<br />
==См. также==<br />
*[[Переобучение]]<br />
*[[Метод опорных векторов (SVM)| SVM]]<sup>[на 28.01.19 не создан]</sup><br />
*[[Дерево решений и случайный лес| Случайный лес]]<br />
*[[Метод главных компонент (PCA)| PCA]]<sup>[на 28.01.19 не создан]</sup><br />
*[[Стохастическое вложение соседей с t-распределением |t-SNE]]<sup>[на 28.01.19 не создан]</sup><br />
==Примечания==<br />
<references/><br />
==Источники информации==<br />
#[http://research.cs.tamu.edu/prism/lectures/pr/pr_l11.pdf Sequential feature selection] {{---}} курс ML Texas A&M University<br />
#[https://en.wikipedia.org/wiki/Feature_selection Feature selection] {{---}} статья про Feature Selection в Wikipedia<br />
#[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117 Публикация про feature selection]<br />
#[https://towardsdatascience.com/feature-selection-using-random-forest-26d7b747597f Embedded random forest]<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Уменьшение размерности]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=69671Обучение с подкреплением2019-01-30T19:43:48Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment''), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти стратегию, приписывающую состояниям (''states'') окружающей среды действия, одно из которых может выбрать агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit о многоруком бандите].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex>;<br />
* множества действий (''actions'') <tex>A</tex>;<br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'').<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex>,<br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://econophysica.ru/services/machine-learning/|Взаимодействие агента со средой]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex>;<br />
* для всех <tex>t = 1 \ldots T</tex>:<br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex>;<br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex>;<br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex>.<br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex>,<br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии;<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем.<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>,<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>,<br />
<br />
Подставляя имеющиеся оценки <tex>V</tex> и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата),<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex>,<br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex>.<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex>;<br />
* для всех <tex>t = 1 \ldots T</tex>:<br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex>;<br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex>;<br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex>.<br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br />,<br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex>.<br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex>,<br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex>,<br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex>.<br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex>,<br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex>;<br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex>,<br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex>.<br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex>.<br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex>;<br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания;<br />
* Обновляем оценки так же как в жадной стратегии.<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex>,<br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex>,<br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex>,<br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний,<br />
* <tex>A</tex> — множество действий,<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> {{---}} функция награды,<br />
* <tex>T = S \times A \rightarrow S</tex> {{---}} функция перехода,<br />
* <tex>\alpha \in [0, 1]</tex> {{---}} learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации,<br />
* <tex>\gamma \in [0, 1]</tex> {{---}} discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий.<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q is not converged:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s is not terminal:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Обучение с подкреплением]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=69670Обучение с подкреплением2019-01-30T19:39:20Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment''), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти стратегию, приписывающую состояниям (''states'') окружающей среды действия, одно из которых может выбрать агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit о многоруком бандите].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex>;<br />
* множества действий (''actions'') <tex>A</tex>;<br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'').<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex>,<br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://econophysica.ru/services/machine-learning/|Взаимодействие агента со средой]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex>;<br />
* для всех <tex>t = 1 \ldots T</tex>;<br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex>;<br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex>;<br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex>.<br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex>,<br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии;<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем.<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>,<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>,<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex>;<br />
* для всех <tex>t = 1 \ldots T</tex>;<br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex>;<br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex>;<br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex>.<br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex>,<br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex>,<br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex>;<br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex>,<br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex>.<br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex>;<br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания;<br />
* Обновляем оценки так же как в жадной стратегии.<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex>,<br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex>,<br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> {{---}} функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> {{---}} функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> {{---}} learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> {{---}} discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q is not converged:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s is not terminal:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Обучение с подкреплением]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4%D1%8B_policy_gradient_%D0%B8_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%B0%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE_%D0%B0%D0%BA%D1%82%D0%BE%D1%80%D0%B0-%D0%BA%D1%80%D0%B8%D1%82%D0%B8%D0%BA%D0%B0&diff=69669Методы policy gradient и алгоритм асинхронного актора-критика2019-01-30T19:35:40Z<p>Dariyakovleva: </p>
<hr />
<div>В алгоритме [[Обучение_с_подкреплением#Q-learning|Q-learning]] агент обучает функцию полезности действия <tex>Q_{\theta}(s, a)</tex>. Стратегия агента <tex>\pi_{\theta}(a|s)</tex> определяется согласно текущим значениям <tex>Q(s, a)</tex> с использованием жадного, <tex>\varepsilon</tex>-жадного или softmax подхода. Однако существуют методы, которые позволяют оптимизировать стратегию <tex>\pi_{\theta}(s|a)</tex> напрямую. Такие алгоритмы относятся к классу алгоритмов ''policy gradient''.<br />
<br />
== Простой policy gradient алгоритм (REINFORCE) ==<br />
<br />
Рассмотрим Марковский процесс принятия решений (МППР), имеющий терминальное состояние. Задача {{---}} максимизировать сумму всех выигрышей <tex>R=r_0 + r_1+\cdots+r_T</tex>, где T {{---}} шаг, на котором произошел переход в терминальное состояние.<br />
<br />
Будем использовать букву <tex>\tau</tex> для обозначения некоторого ''сценария'' {{---}} последовательности состояний и произведенных в них действий: <tex>\tau = (s_1, a_1, s_2, a_2, ... s_T, a_T)</tex>. Будем обозначать сумму всех выигрышей, полученных в ходе сценария, как <tex>R_{\tau} = \sum_{\tau} {r(s_t, a_t)}</tex>.<br />
<br />
Не все сценарии равновероятны. Вероятность реализации сценария зависит от поведения среды, которое задается вероятностями перехода между состояниями <tex>p(s_{t+1}|s_{t}, a_{t})</tex>, распределением начальных состояний <tex>p(s_1)</tex> и поведения агента, которое определяется его стохастической стратегией <tex>\pi_{\theta}(a_t|s_t)</tex>. Вероятностное распределение над сценариями, таким образом, задается как<br />
<br />
:<tex>p_{\theta}(\tau) = p_{\theta}(s_1, a_1, ... s_T, a_T) = p(s_1) \prod_{t=1}^{T} {\pi_{\theta}(a_t|s_t) p(s_{t+1}|s_t, a_t)}</tex>,<br />
<br />
Мы предполагаем, что вероятности переходов между состояниями агенту неизвестны, то есть у агента нет модели поведения окружающей среды (''model-free learning'').<br />
<br />
Нам нужно выбрать такой набор параметров агента <tex>\theta</tex>, задающий <tex>\pi_{\theta}(a|s)</tex>, чтобы максимизировать матожидание суммы полученных выигрышей:<br />
<br />
:<tex>J(\theta) = E_{\tau \sim p_{\theta}(\tau)} \left[ R_{\tau} \right] = \int {p_{\theta}(\tau) R_{\tau} d\tau}</tex>,<br />
<br />
Пусть мы хотим максимизировать функцию <tex>J(\theta)</tex> методом градиентного подъема. Для этого нам необходимо уметь рассчитывать ее градиент:<br />
<br />
: <tex>\nabla_{\theta} J(\theta) = \int {\nabla_{\theta}p_{\theta}(\tau) R_{\tau} d\tau} </tex>,<br />
<br />
Мы не можем подсчитать <tex>\nabla_{\theta}p_{\theta}(\tau)</tex> напрямую, потому что в выражение для <tex>p_{\theta}(\tau)</tex> входят вероятности переходов между состояниями, которые агенту неизвестны. Однако, так как<br />
<br />
: <tex>p_{\theta}(\tau) \nabla_{\theta} \log p_{\theta}(\tau) = p_{\theta}(\tau) \frac{\nabla_{\theta}p_{\theta}(\tau)}{p_{\theta}(\tau)} = \nabla_{\theta}p_{\theta}(\tau)</tex>,<br />
<br />
то мы можем заменить <tex>\nabla_{\theta}p_{\theta}(\tau)</tex> на <tex>p_{\theta}(\tau) \nabla_{\theta} \log p_{\theta}(\tau)</tex>:<br />
<br />
: <tex>\nabla_{\theta} J(\theta) = \int {p_{\theta}(\tau) \nabla_{\theta} \log p_{\theta}(\tau) R_{\tau} d\tau} = E_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) R_{\tau} \right]</tex>,<br />
<br />
Рассмотрим <tex>\log p_{\theta}(\tau)</tex>:<br />
<br />
: <tex> \log p_{\theta}(\tau) = \log \left( p(s_1) \prod_{t=1}^{T} {\pi_{\theta}(a_t|s_t) p(s_{t+1}|s_t, a_t)} \right) = \log p(s_1) + \sum_{t=1}^{T} {\left( \log \pi_{\theta}(a_t|s_t) + \log p(s_{t+1}|s_t, a_t) \right)} </tex>,<br />
<br />
Тогда:<br />
<br />
: <tex> \nabla_{\theta} \log p_{\theta}(\tau) = \underbrace{\nabla_{\theta} \log p(s_1)}_{=0} + \sum_{t=1}^{T} {\left( \nabla_{\theta} \log \pi_{\theta}(a_t|s_t) + \underbrace{\nabla_{\theta} \log p(s_{t+1}|s_t, a_t)}_{=0} \right)} = \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t|s_t)} </tex>,<br />
<br />
Подставляя в определение <tex>\nabla_{\theta} J(\theta)</tex>:<br />
<br />
: <tex> \nabla_{\theta} J(\theta) = E_{\tau \sim p_{\theta}(\tau)} \left[ \left( \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t|s_t)} \right) R_{\tau} \right] </tex>,<br />
<br />
[[File:Policy-gradient-reinforce.png|thumb|313px|link=http://rll.berkeley.edu/deeprlcourse/f17docs/lecture_4_policy_gradient.pdf|Схема алгоритма REINFORCE]]<br />
<br />
Заметим, что в получившееся выражение для <tex>\nabla_{\theta} J(\theta)</tex> уже не входят напрямую значения <tex>p(s_{t+1}|s_{t}, a_{t})</tex> и <tex>p(s_1)</tex>, которые нам неизвестны. Таким образом, если у нас есть в наличии сценарий <tex>\tau</tex> и соответствующее ему значение <tex>R_\tau</tex>, мы можем вычислить величину <tex>\left( \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t|s_t)} \right) R_{\tau}</tex>. Значит, если у нас есть выборка из <tex>N</tex> уже известных сценариев <tex>\tau^i = (s_1^i, a_1^i, ... s_{T^i}^i, a_{T^i}^i)</tex>, полученная из распределения <tex>\tau \sim p_{\theta}(\tau)</tex>, то мы можем приблизить посчитать приблизительное значение <tex>\nabla_{\theta} J(\theta)</tex> по методу Монте-Карло {{---}} вычислив выборочное среднее случайной величины:<br />
<br />
: <tex> \nabla_{\theta} J(\theta) \approx \frac{1}{N} \sum_{i=1}^N { \left( \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t^i|s_t^i)} \right) R_{\tau^i}} = \frac{1}{N} \sum_{i=1}^N { \left( \sum_{t=1}^{T^i} {\nabla_{\theta} \log \pi_{\theta}(a_t^i|s_t^i)} \right) \left( \sum_{t=1}^{T^i} { r(s_t^i, a_t^i) } \right)} </tex>,<br />
<br />
Осталось понять, как получить несмещенную выборку сценариев <tex>\tau</tex> из вероятностного распределения <tex>p_{\theta}(\tau)</tex>. Однако это очень просто {{---}} нам всего лишь нужно зафиксировать параметр <tex>\theta</tex> и провзаимодействовать со средой, так как распределение <tex>p_{\theta}(\tau)</tex> задает именно вероятность реализации сценария <tex>\tau</tex> при взаимодействии агента с фиксированной стратегией со средой. <br />
<br />
Таким образом, оптимизировать <tex>J(\theta)</tex> можно с помощью следующего простого алгоритма (REINFORCE):<br />
<br />
# Прогнать <tex>N</tex> сценариев <tex>\tau_i</tex> со стратегией <tex>\pi_{\theta}(a|s)</tex>;<br />
# Посчитать среднее арифметическое <tex>\nabla_{\theta} J(\theta) \leftarrow \frac{1}{N} \sum_{i=1}^N { \left( \sum_{t=1}^{T^i} {\nabla_{\theta} \log \pi_{\theta}(a_t^i|s_t^i)} \right) \left( \sum_{t=1}^{T^i} { r(s_t^i, a_t^i) } \right)}</tex>;<br />
# <tex> \theta \leftarrow \theta + \alpha \nabla_{\theta} J(\theta)</tex>;<br />
# Если не сошлись к экстремуму, повторить с пункта 1.<br />
<br />
=== Интуитивное объяснение принципа работы ===<br />
<br />
[[File:Policy-gradient-trajectories.png|thumb|313px|link=http://rll.berkeley.edu/deeprlcourse/f17docs/lecture_4_policy_gradient.pdf|Иллюстрация выбора наилучшего сценария]]<br />
<br />
<tex>p_{\theta}(\tau)</tex> {{---}} это вероятность того, что будет реализован сценарий <tex>\tau</tex> при условии параметров модели <tex>\theta</tex>, т. е. функция ''правдоподобия''. Нам хочется увеличить правдоподобие "хороших" сценариев (обладающих высоким <tex>R_{\tau}</tex>) и понизить правдоподобие "плохих" сценариев (с низким <tex>R_{\tau}</tex>).<br />
<br />
Взглянем еще раз на полученное определение градиента функции полного выигрыша:<br />
<br />
: <tex>\nabla_{\theta} J(\theta) = E_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) R_{\tau} \right]</tex>,<br />
<br />
Двигаясь вверх по этому градиенту, мы повышаем логарифм функции правдоподобия для сценариев, имеющих большой положительный <tex>R_{\tau}</tex>.<br />
<br />
== Преимущества и недостатки policy gradient по сравнению с Q-learning ==<br />
<br />
Преимущества:<br />
<br />
* Легко обобщается на задачи с большим множеством действий, в том числе на задачи с непрерывным множеством действий;<br />
* По большей части избегает конфликта между эксплуатацией (exploitation) и исследованием (exploration), так как оптимизирует напрямую стохастическую стратегию <tex>\pi_{\theta}(a|s)</tex>;<br />
* Имеет более сильные гарантии сходимости: если Q-learning гарантированно сходится только для МППР с конечными множествами действий и состояний, то policy gradient, при достаточно точных оценках <tex>\nabla_{\theta} J(\theta)</tex> (т. е. при достаточно больших выборках сценариев), сходится к локальному оптимуму всегда, в том числе в случае бесконечных множеств действий и состояний, и даже для частично наблюдаемых Марковских процессов принятия решений (ЧНМППР, англ. ''partially observed Markov decision process, POMDP'').<br />
<br />
Недостатки:<br />
<br />
* Очень низкая скорость работы {{---}} требуется большое количество вычислений для оценки <tex>\nabla_{\theta} J(\theta)</tex> по методу Монте-Карло, так как:<br />
** для получения всего одного семпла требуется произвести <tex>T</tex> взаимодействий со средой;<br />
** случайная величина <tex>\nabla_{\theta} \log p_{\theta}(\tau) R_{\tau}</tex> имеет большую дисперсию, так как для разных <tex>\tau</tex> значения <tex>R_{\tau}</tex> могут очень сильно различаться, поэтому для точной оценки <tex>\nabla_{\theta} J(\theta) = E_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) R_{\tau} \right]</tex> требуется много семплов;<br />
** cемплы, собранные для предыдущих значений <tex>\theta</tex>, никак не переиспользуются на следующем шаге, семплирование нужно делать заново на каждом шаге градиентного спуска.<br />
* В случае конечных МППР Q-learning сходится к глобальному оптимуму, тогда как policy gradient может застрять в локальном.<br />
<br />
Далее мы рассмотрим способы ускорения работы алгоритма.<br />
<br />
== Усовершенствования алгоритма ==<br />
<br />
=== Опорные значения ===<br />
<br />
Заметим, что если <tex>b</tex> - константа относительно <tex>\tau</tex>, то<br />
<br />
: <tex>E_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) (R_{\tau} - b) \right] = E_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) R_{\tau} \right] </tex>,<br />
<br />
так как<br />
<br />
: <tex>E_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) b \right] = \int {p_{\theta}(\tau) \nabla_{\theta} \log p_{\theta}(\tau) b d\tau} = \int {\nabla_{\theta} p_{\theta}(\tau) b d\tau} = b \nabla_{\theta} \int {p_{\theta}(\tau) d\tau} = b \nabla_{\theta} 1 = 0</tex>,<br />
<br />
Таким образом, изменение <tex>R_{\tau}</tex> на константу не меняет оценку <tex>\nabla_{\theta} J(\theta)</tex>. Однако ''дисперсия'' <tex> Var_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) (R_{\tau} - b) \right]</tex> зависит от <tex>b</tex>:<br />
<br />
: <tex> Var_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) (R_{\tau} - b) \right] = \underbrace{E_{\tau \sim p_{\theta}(\tau)} \left[ \left( \nabla_{\theta} \log p_{\theta}(\tau) (R_{\tau} - b) \right)^2 \right]}_{\text{depends on } b} - \underbrace{E_{\tau \sim p_{\theta}(\tau)} \left[ \nabla_{\theta} \log p_{\theta}(\tau) (R_{\tau} - b) \right]^2}_{= E \left[ \nabla_{\theta} \log p_{\theta}(\tau) R_{\tau} \right]^2} </tex>,<br />
<br />
поэтому, регулируя <tex>b</tex>, можно достичь более низкой дисперсии, а значит, более быстрой сходимости метода Монте-Карло к истинному значению <tex>\nabla_{\theta} J(\theta)</tex>. Значение <tex>b</tex> называется ''опорным значением''. Способы определения опорных значений будут рассмотрены далее, в рамках рассмотрения алгоритма актора-критика (Actor-Critic).<br />
<br />
=== Использование будущего выигрыша вместо полного выигрыша ===<br />
<br />
Рассмотрим еще раз выражение для градиента полного выигрыша:<br />
<br />
: <tex> \nabla_{\theta} J(\theta) = E_{\tau \sim p_{\theta}(\tau)} \left[ \left( \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t|s_t)} \right) R_{\tau} \right] = E_{\tau \sim p_{\theta}(\tau)} \left[ \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t|s_t)} \left( \sum_{t=1}^{T} {r(s_t, a_t)} \right) \right]</tex>,<br />
<br />
Так как в момент времени <tex>t</tex> от действия <tex>a_t</tex> зависят только <tex>r(s_{t'}, a_{t'})</tex> для <tex> t' \leq t</tex>, это выражение можно переписать как<br />
<br />
: <tex> \nabla_{\theta} J(\theta) \approx E_{\tau \sim p_{\theta}(\tau)} \left[ \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t|s_t)} \underbrace{\left( \sum_{t'=t}^{T} {r(s_{t'}, a_{t'})} \right)}_{= Q_{\tau, t}} \right]</tex>,<br />
<br />
Величина <tex>Q_{\tau, t}</tex> {{---}} ''будущий выигрыш'' (reward-to-go) на шаге <tex>t</tex> в сценарии <tex>\tau</tex><br />
<br />
== Алгоритм актора-критика с преимуществом (англ. Advantage Actor Critic, A2C) ==<br />
<br />
Из предыдущего абзаца:<br />
<br />
: <tex>\nabla_{\theta} J(\theta) \approx \frac{1}{N} \sum_{i=1}^{N} \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t^i|s_t^i) Q_{\tau_i, t} } </tex>,<br />
<br />
Здесь <tex>Q_{\tau_i, t}</tex> {{---}} оценка будущего выигрыша из состояния <tex>s_t^i</tex> при условии действия <tex>a_t^i</tex>, которая базируется только на одном сценарии <tex>\tau_i</tex>. Это плохое приближение ожидаемого будущего выигрыша {{---}} истинный ожидаемый будущий выигрыш выражается формулой<br />
<br />
: <tex> Q^{\pi}(s_t, a_t) = \sum_{t'=t}^{T} {E_{\pi_{\theta}} [r(s_{t'}, a_{t'}) | s_t, a_t] } </tex>,<br />
<br />
Также, в целях уменьшения дисперсии случайной величины, введем опорное значение для состояния <tex>s_t</tex>, которое назовем ''ожидаемой ценностью'' (value) этого состояния. Ожидаемая ценность состояния <tex>s_t</tex> {{---}} ожидаемый будущий выигрыш при совершении некоторого действия в этом состоянии согласно стратегии <tex>\pi_{\theta}(a|s)</tex>:<br />
<br />
: <tex> V^{\pi}(s_t) = E_{a_t \sim \pi_{\theta}(a_t | s_t)} [Q^{\pi}(s_t, a_t)] = \sum_{t'=t}^{T} {E_{\pi_{\theta}} [r(s_{t'}, a_{t'}) | s_t]}</tex>,<br />
<br />
Таким образом, вместо ожидаемого будущего выигрыша при оценке <tex>\nabla_{\theta} J(\theta)</tex> будем использовать функцию ''преимущества'' (advantage):<br />
<br />
: <tex> A^{\pi}(s_t, a_t) = Q^{\pi}(s_t, a_t) - V^{\pi}(s_t) </tex>,<br />
<br />
Преимущество действия <tex>a_t</tex> в состоянии <tex>s_t</tex> {{---}} величина, характеризующая то, насколько выгоднее в состоянии <tex>s_t</tex> выбрать именно действие <tex>a_t</tex>.<br />
<br />
Итого:<br />
<br />
: <tex> \nabla_{\theta} J(\theta) \approx \frac{1}{N} \sum_{i=1}^{N} \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t^i|s_t^i) A^{\pi}(s_t^i, a_t^i) } </tex>,<br />
<br />
Как достаточно точно и быстро оценить <tex>A^{\pi}(s_t^i, a_t^i)</tex>? Сведем задачу к оценке <tex>V^{\pi}(s_t)</tex>:<br />
<br />
: <tex> Q^{\pi}(s_t, a_t) = r(s_t, a_t) + E_{s_{t+1} \sim p(s_{t+1} | s_t, a_t)} [V^{\pi}(s_{t+1})] \approx r(s_t, a_t) + V^{\pi}(s_{t+1}) </tex>,<br />
: <tex> A^{\pi}(s_t^i, a_t^i) = Q^{\pi}(s_t, a_t) - V^{\pi}(s_t) \approx r(s_t, a_t) + V^{\pi}(s_{t+1}) - V^{\pi}(s_t) </tex>,<br />
<br />
Теперь нам нужно уметь оценивать <tex>V^{\pi}(s_t) = \sum_{t'=t}^{T} {E_{\pi_{\theta}} [r(s_{t'}, a_{t'}) | s_t] }</tex>. Мы можем делать это, опять же, с помощью метода Монте-Карло {{---}} так мы получим несмещенную оценку. Но это будет работать не существенно быстрее, чем обычный policy gradient. Вместо этого заметим, что при фиксированных <tex>s_t</tex> и <tex>a_t</tex> выполняется:<br />
<br />
: <tex> V^{\pi}(s_t) = r(s_t, a_t) + V^{\pi}(s_{t+1})</tex>,<br />
<br />
Таким образом, если мы имеем некоторую изначальную оценку <tex>V^{\pi}(s)</tex> для всех <tex>s</tex>, то мы можем обновлять эту оценку путем, аналогичным алгоритму Q-learning:<br />
<br />
: <tex> V^{\pi}(s_t) \leftarrow (1 - \beta) V^{\pi}(s_t) + \beta (r(s_t, a_t) + V^{\pi}(s_{t+1})) </tex>,<br />
<br />
Здесь <tex>\beta</tex> {{---}} коэффициент обучения (''learning rate'') для функции ценности. Такой пересчет мы можем производить каждый раз, когда агент получает вознаграждение за действие. Так мы получим оценку ценности текущего состояния, не зависящую от выбранного сценария развития событий <tex>\tau</tex>, а значит, и оценка функции преимущества не будет зависеть от выбора конкретного сценария. Это сильно снижает дисперсию случайной величины <tex>\nabla_{\theta} \log \pi_{\theta}(a_t^i|s_t^i) A^{\pi}(s_t^i, a_t^i)</tex>, что делает оценку <tex>\nabla_{\theta} J(\theta)</tex> достаточно точной даже в том случае, когда мы используем всего один сценарий для ее подсчета:<br />
<br />
: <tex>\nabla_{\theta} J(\theta) \approx \sum_{t=1}^{T} {\nabla_{\theta} \log \pi_{\theta}(a_t|s_t) A^{\pi}(s_t, a_t) }</tex>,<br />
<br />
На практике же мы можем аппроксимировать <tex>\nabla_{\theta} J(\theta)</tex> на каждом шаге (в онлайне), основываясь на всего одном действии каждый раз. Алгоритм в итоге будет следующим:<br />
<br />
# производим действие <tex>a \sim \pi_{\theta}(a|s)</tex>, переходим в состояние <tex>s'</tex> и получаем вознаграждение <tex>r</tex>;<br />
# <tex>V^{\pi}(s) \leftarrow (1 - \beta) V^{\pi}(s) + \beta (r + V^{\pi}(s'))</tex>;<br />
# <tex>A_{\pi}(s, a) \leftarrow r + V^{\pi}(s') - V^{\pi}(s) </tex>;<br />
# <tex>\nabla_{\theta} J(\theta) \leftarrow \nabla_{\theta} \log \pi_{\theta}(a|s) A^{\pi}(s, a)</tex>;<br />
# <tex>\theta \leftarrow \theta + \alpha \nabla_{\theta} J(\theta)</tex>;<br />
# Если не сошлись к экстремуму, повторить с пункта 1.<br />
<br />
Такой алгоритм называется алгоритмом актора-критика с преимуществом (Advantage Actor-Critic). Актором здесь называется компонента, которая оптимизирует стратегию <tex>\pi_{\theta}(a|s)</tex>, а критиком {{---}} компонента, которая подсчитывает ценности состояний <tex>V^{\pi}(s)</tex>. Актор определяет дальнейшее действие, а критик оценивает, насколько то или иное действие выгодно, основываясь на функции преимущества (advantage).<br />
<br />
Алгоритм актора-критика считается гибридным, так как актор работает в соответствии с принципом policy gradient, а критик работает аналогично алгоритму Q-routing.<br />
<br />
=== Асинхронный актор-критик (англ. Asynchronous Advantage Actor-Critic, A3C) ===<br />
<br />
[[File:Async-actor-critic.png|thumb|313px|link=http://rll.berkeley.edu/deeprlcourse/f17docs/lecture_5_actor_critic_pdf.pdf|Иллюстрация работы алгоритма асинхронного актора-критика]]<br />
<br />
Проблема с обучением с подкреплением в онлайне заключается в том, что данные, поступающие на вход алгоритму обучения, сильно скоррелированы: каждое следующее состояние непосредственно зависит от предпринятых агентом действий. Обучение на сильно скоррелированных данных приводит к переобучению. Таким образом, для того, чтобы успешно обучить стратегию, обобщаемую на большое количество состояний среды, нам все еще необходимо обучаться на эпизодах из различных сценариев.<br />
<br />
Одним из способов достичь этого является запуск множества агентов параллельно. Все агенты находятся в разных состояниях и выбирают различные конкретные действия согласно стохастической стратегии <tex>\pi_{\theta}(a|s)</tex>, тем самым достигается устранение корреляции между наблюдаемыми данными. Однако все агенты используют и оптимизируют один и тот же набор параметров <tex>\theta</tex>.<br />
<br />
Идея алгоритма асинхронного актора-критика заключается в том, чтобы запустить <tex>N</tex> агентов параллельно, при этом на каждом шаге каждый из агентов рассчитывает обновления для значений <tex>V^{\pi}(s)</tex> и <tex>\theta</tex>. Однако, вместо того, чтобы просто продолжить работу, каждый агент обновляет <tex>V^{\pi}(s)</tex> и <tex>\theta</tex>, общие для всех агентов. Перед обработкой каждого нового эпизода агент копирует текущие глобальные значения параметра <tex>\theta</tex> и использует его, чтобы определить собственную стратегию на этот эпизод. Агенты не ждут, пока остальные агенты завершат обработку своих эпизодов, чтобы обновить глобальные параметры (отсюда ''асинхронный''). Поэтому пока один из агентов обрабатывает один эпизод, глобальное значение <tex>\theta</tex> может изменяться вследствие действий других агентов.<br />
<br />
=== Реализация асинхронного актора-критика на основе нейронных сетей ===<br />
<br />
[[File:Actor-critic-nn.png|thumb|313px|link=http://rll.berkeley.edu/deeprlcourse/f17docs/lecture_5_actor_critic_pdf.pdf|Совместная архитектура нейросети для алгоритма актора-критика]]<br />
<br />
В большинстве современных исследований стратегия <tex>\pi_{\theta}(a|s)</tex> и функция ценности <tex>V^{\pi}(s)</tex> задаются с помощью нейросетей. Каждая из функций может в принципе использовать отдельную нейросеть, но на практике чаще всего применяется совмещенная нейросеть с двумя выходными слоями {{---}} для стратегии и для функции ценности. Такой подход, как правило, приводит к лучшим результатам, так как функция ценности, вообще говоря, зависит от текущей стратегии.<br />
<br />
Реализация алгоритма асинхронного актора-критика инициализирует глобальную нейросеть (master network) и запускает N дочерних процессов (workers), в каждом из которых агент взаимодействует со средой. Нейросеть каждого агента является копией материнской нейросети. Перед началом каждого эпизода веса из материнской нейросети заново копируются в нейросеть агента. Градиенты, посчитанные по агентской нейросети, применяются в итоге к материнской.<br />
<br />
== См. также ==<br />
<br />
* [[Обучение с подкреплением]]<br />
<br />
== Ссылки == <br />
<br />
* [https://link.springer.com/content/pdf/10.1007/BF00992696.pdf Williams, Ronald J. "Simple statistical gradient-following algorithms for connectionist reinforcement learning." Machine learning 8.3-4 (1992): 229-256.]<br />
* [http://papers.nips.cc/paper/1713-policy-gradient-methods-for-reinforcement-learning-with-function-approximation.pdf Sutton, Richard S., et al. "Policy gradient methods for reinforcement learning with function approximation." Advances in neural information processing systems. 2000.]<br />
* [http://rll.berkeley.edu/deeprlcourse/f17docs/lecture_4_policy_gradient.pdf Policy Gradients. CS 294-112: Deep Reinforcement Learning, Sergey Levine.] <br />
* [http://rail.eecs.berkeley.edu/deeprlcourse-fa17/f17docs/lecture_5_actor_critic_pdf.pdf Actor-Critic Algorithms. CS 294-112: Deep Reinforcement Learning, Sergey Levine.]<br />
* [https://medium.com/emergent-future/simple-reinforcement-learning-with-tensorflow-part-8-asynchronous-actor-critic-agents-a3c-c88f72a5e9f2 Simple Reinforcement Learning with Tensorflow Part 8: Asynchronous Actor-Critic Agents (A3C)]<br />
<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Обучение с подкреплением]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B_%D0%BA%D0%BE%D0%B4%D0%B0_%D0%BD%D0%B0_Scala&diff=69668Примеры кода на Scala2019-01-30T19:19:46Z<p>Dariyakovleva: </p>
<hr />
<div>[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]<br />
<br />
==Популярные библиотеки==<br />
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>;[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировать данными и позволяет реализовать матричные и векторные операции, решать задачи оптимизации, обрабатывать сигналы устройств;<br />
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста;<br />
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого;<br />
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala;<br />
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.<br />
<br />
==Примеры кода==<br />
===Линейная регрессия===<br />
{{main|Линейная регрессия|l1=Линейная регрессия<sup>[на 28.01.19 не создан]</sup>}}<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"<br />
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:<br />
'''val '''training = spark.read.format("libsvm")<br />
.load("linear_regression.txt")<br />
'''val '''lr = '''new '''LinearRegression()<br />
.setMaxIter(10)<br />
.setRegParam(0.3)<br />
.setElasticNetParam(0.8)<br />
'''val '''lrModel = lr.fit(training)<br />
Вывод итоговых параметров модели:<br />
println(lrModel.coefficients)<br />
println(lrModel.intercept)<br />
'''val '''trainingSummary = lrModel.summary<br />
println(trainingSummary.totalIterations)<br />
println(trainingSummary.objectiveHistory.mkString(","))<br />
trainingSummary.residuals.show()<br />
println(trainingSummary.rootMeanSquaredError)<br />
println(trainingSummary.r2)<br />
<br />
===Вариации регрессии===<br />
{{main|Вариации регрессии}}<br />
<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:<br />
'''import '''smile.data.{AttributeDataset, NumericAttribute}<br />
'''import '''smile.read<br />
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}<br />
<br />
'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))<br />
'''val '''x: Array[Array['''Double''']] = data.x()<br />
'''val '''y: Array['''Double'''] = data.y()<br />
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)<br />
'''val '''lassoRegression: LASSO = lasso(x, y, 10)<br />
println(ridgeRegression)<br />
println(lassoRegression)<br />
<br />
===Логистическая регрессия===<br />
{{main|Логистическая регрессия}}<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"<br />
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:<br />
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}<br />
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics<br />
'''import '''org.apache.spark.mllib.regression.LabeledPoint<br />
'''import '''org.apache.spark.mllib.util.MLUtils<br />
<br />
'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")<br />
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)<br />
'''val '''training = splits(0).cache()<br />
'''val '''test = splits(1)<br />
'''val '''model = '''new '''LogisticRegressionWithLBFGS()<br />
.setNumClasses(10)<br />
.run(training)<br />
<br />
'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =><br />
'''val '''prediction = model.predict(features)<br />
(prediction, label)<br />
}<br />
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)<br />
'''val '''accuracy = metrics.accuracy<br />
println(accuracy)<br />
<br />
===Классификация при помощи MLP===<br />
{{main|Нейронные сети, перцептрон}}<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:<br />
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}<br />
'''import '''smile.data.{AttributeDataset, NumericAttribute}<br />
'''import '''smile.read<br />
'''import '''smile.classification.mlp<br />
'''import '''smile.plot.plot<br />
<br />
'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = data.x()<br />
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)<br />
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)<br />
plot(x, y, mlpModel)<br />
<br />
===Рекуррентные нейронные сети===<br />
{{main|Рекуррентные нейронные сети}}<br />
<br />
Пример кода, с использованием библиотеки DeepLearning.scala<br />
<span style="color:#3D9970>// Задание слоёв</span><br />
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {<br />
'''val '''exp_x = hyperparameters.exp(x)<br />
'''val '''exp_nx = hyperparameters.exp(-x)<br />
(exp_x - exp_nx) / (exp_x + exp_nx)<br />
}<br />
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {<br />
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)<br />
'''val '''yraw = why.dot(hnext) + by<br />
'''val '''yraw_exp = hyperparameters.exp(yraw)<br />
'''val '''prob = yraw_exp / yraw_exp.sum<br />
'''val '''loss = -hyperparameters.log((prob * y).sum)<br />
(loss, prob, hnext)<br />
}<br />
<br />
<span style="color:#3D9970>// Определение структуры</span><br />
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector<br />
type WithHiddenLayer[A] = (A, INDArrayLayer)<br />
type Batch = IndexedSeq[(Char, Char)]<br />
type Losses = Vector['''Double''']<br />
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {<br />
batch '''match '''{<br />
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {<br />
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =><br />
(bstate, xy) '''match '''{<br />
'''case '''((tot, localhprev), (x, y)) => {<br />
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{<br />
'''case '''(localloss, _, localhnext) => {<br />
(tot + localloss, localhnext)<br />
}<br />
}<br />
}<br />
}<br />
}<br />
}<br />
}<br />
<br />
<span style="color:#3D9970>// Определение одного шага обучения</span><br />
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)<br />
'''def '''singleRound(initprevloss: Losses): Future[Losses] =<br />
(batches.foldLeftM((initprevloss, initH)) {<br />
(bstate: WithHiddenLayer[Losses], batch: Batch) =><br />
bstate '''match '''{<br />
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{<br />
'''case '''(bloss, hnext) => bloss.train.map {<br />
(blossval: '''Double''') => {<br />
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001<br />
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001<br />
(loss_seq, hnext)<br />
}<br />
}<br />
}<br />
}<br />
}).map {<br />
(fstate: WithHiddenLayer[Losses]) =><br />
fstate '''match '''{<br />
'''case '''(floss, _) => floss<br />
}<br />
}<br />
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {<br />
(ploss: Losses, round: '''Int''') => {<br />
singleRound(ploss)<br />
}<br />
}<br />
<br />
<span style="color:#3D9970>// Обучение сети</span><br />
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)<br />
'''val '''losses = unsafePerformFuture(allRounds)<br />
<br />
===Долгая краткосрочная память===<br />
Основная статья: [[Долгая краткосрочная память]].<br />
<br />
[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref><br />
<br />
===Обработка естественного языка===<br />
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].<br />
<br />
===Метрический классификатор и метод ближайших соседей===<br />
Основная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].<br />
<br />
===Метод опорных векторов===<br />
Основная статья: [[Метод опорных векторов (SVM)]]<sup>[на 28.01.19 не создан]</sup>.<br />
<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:<br />
'''import '''smile.classification._<br />
'''import '''smile.data._<br />
'''import '''smile.plot._<br />
'''import '''smile.read<br />
'''import '''smile.validation.FMeasure<br />
<br />
'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = iris.x()<br />
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)<br />
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)<br />
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)<br />
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)<br />
plot(x, y, SVM)<br />
<br />
===Дерево решений и случайный лес===<br />
Основная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].<br />
<br />
===Байесовская классификация===<br />
Основная статья: [[Байесовская классификация]]<sup>[на 28.01.19 не создан]</sup>.<br />
<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"<br />
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:<br />
<span style="color:#3D9970>// Создание модели</span><br />
'''val '''bayes = '''new '''BayesClassifier[String, String]()<br />
<span style="color:#3D9970>// Задание соотвествия категория - слово</span><br />
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)<br />
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)<br />
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)<br />
<span style="color:#3D9970>// Тестовые примеры</span><br />
'''val '''unknownText1 = "I use git".split(" ")<br />
'''val '''unknownText2 = "Today's weather is snow".split(" ")<br />
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")<br />
<span style="color:#3D9970>// Классификация</span><br />
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) <span style="color:#3D9970>// technology</span><br />
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) <span style="color:#3D9970>// weather</span><br />
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) <span style="color:#3D9970>// government</span><br />
<br />
===EM-алгоритм===<br />
Основная статья: [[EM-алгоритм]]<sup>[на 28.01.19 не создан]</sup>.<br />
<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:<br />
'''import '''smile.clustering._<br />
'''import '''smile.data._<br />
'''import '''smile.plot._<br />
'''import '''smile.read<br />
<br />
'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = iris.x()<br />
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)<br />
'''val '''y = kMeans.getClusterLabel<br />
plot(x, y, '.', Palette.COLORS)<br />
<br />
===Бустинг, AdaBoost===<br />
Основная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].<br />
<br />
===Уменьшение размерности===<br />
Основная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].<br />
<br />
== Примечания ==<br />
<references/><br />
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B_%D0%BA%D0%BE%D0%B4%D0%B0_%D0%BD%D0%B0_Scala&diff=69667Примеры кода на Scala2019-01-30T19:19:02Z<p>Dariyakovleva: </p>
<hr />
<div>[[File:scala_logo.png|auto|thumb|Scala: https://www.scala-lang.org/]]<br />
<br />
==Популярные библиотеки==<br />
* Breeze<ref>[https://github.com/scalanlp/breeze Breeze]</ref> {{---}} библиотека, которая копирует реализует идеи строения структур данных из MATLAB<ref>[https://www.mathworks.com/help/matlab/structures.html MATLAB, structures]</ref> и NumPy<ref>;[https://en.wikipedia.org/wiki/NumPy NumPy wiki]</ref>. Breeze позволяет быстро манипулировать данными и позволяет реализовать матричные и векторные операции, решать задачи оптимизации, обрабатывать сигналы устройств;<br />
* Epic<ref>[http://www.scalanlp.org/ ScalaNLP, Epic]</ref> {{---}} часть ScalaNLP, позволяющая парсить и обрабатывать текст, поддерживающая использование GPU. Так же имеет фрэймворк для предсказаний текста;<br />
* Smpile<ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} развивающийся проект, похожий на scikit-learn<ref>[https://scikit-learn.org/ scikit-learn]</ref>, разработанный на Java и имеющий API для Scala. Имеет большой набор алгоритмов для решения задач классификации, регрессии, выбора фичей и другого;<br />
* Apache Spark MLlib<ref>[https://spark.apache.org/mllib/ Apache Spark MLlib]</ref> {{---}} построенная на Spark<ref>[https://spark.apache.org/ Apache Spark]</ref> имеет большой набор алгоритмов, написанный на Scala;<br />
* DeepLearning.scala <ref>[https://deeplearning.thoughtworks.school/ DeppLearning.scala]</ref> {{---}} набор инструментов для глубокого обучения<ref>[http://neerc.ifmo.ru/wiki/index.php?title=%D0%93%D0%BB%D1%83%D0%B1%D0%BE%D0%BA%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Глубокое обучение]</ref>. Позволяет создавать динамические нейронные сети, давая возможность параллельных вычеслений.<br />
<br />
==Примеры кода==<br />
===Линейная регрессия===<br />
{{main|Линейная регрессия|l1=Линейная регрессия<sup>[на 28.01.19 не создан]</sup>}}<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"<br />
Пример линейной регрессии c применением org.apache.spark.ml.regression.LinearRegression<ref>[https://spark.apache.org/docs/latest/ml-classification-regression.html#linear-regression Spark, LinearRegression]</ref>:<br />
'''val '''training = spark.read.format("libsvm")<br />
.load("linear_regression.txt")<br />
'''val '''lr = '''new '''LinearRegression()<br />
.setMaxIter(10)<br />
.setRegParam(0.3)<br />
.setElasticNetParam(0.8)<br />
'''val '''lrModel = lr.fit(training)<br />
Вывод итоговых параметров модели:<br />
println(lrModel.coefficients)<br />
println(lrModel.intercept)<br />
'''val '''trainingSummary = lrModel.summary<br />
println(trainingSummary.totalIterations)<br />
println(trainingSummary.objectiveHistory.mkString(","))<br />
trainingSummary.residuals.show()<br />
println(trainingSummary.rootMeanSquaredError)<br />
println(trainingSummary.r2)<br />
<br />
===Вариации регрессии===<br />
{{main|Вариации регрессии}}<br />
<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример ридж и лассо регрессии c применением smile.regression<ref>[https://haifengl.github.io/smile/regression.html Smile, Regression]</ref>:<br />
'''import '''smile.data.{AttributeDataset, NumericAttribute}<br />
'''import '''smile.read<br />
'''import '''smile.regression.{LASSO, RidgeRegression, lasso, ridge}<br />
<br />
'''val '''data: AttributeDataset = read.table("regression.txt", delimiter = " ", response = Some(('''new '''NumericAttribute("class"), 0)))<br />
'''val '''x: Array[Array['''Double''']] = data.x()<br />
'''val '''y: Array['''Double'''] = data.y()<br />
'''val '''ridgeRegression: RidgeRegression = ridge(x, y, 0.0057)<br />
'''val '''lassoRegression: LASSO = lasso(x, y, 10)<br />
println(ridgeRegression)<br />
println(lassoRegression)<br />
<br />
===Логистическая регрессия===<br />
{{main|Логистическая регрессия}}<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-core" '''%''' "2.4.0"<br />
libraryDependencies '''+=''' "org.apache.spark" '''%%''' "spark-mllib" '''%''' "2.4.0" '''%''' "runtime"<br />
Пример логистической регрессии c применением spark.mllib.classification<ref>[https://spark.apache.org/docs/2.3.1/mllib-linear-methods.html#logistic-regression Spark, Logistic Regression]</ref>:<br />
'''import '''org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS}<br />
'''import '''org.apache.spark.mllib.evaluation.MulticlassMetrics<br />
'''import '''org.apache.spark.mllib.regression.LabeledPoint<br />
'''import '''org.apache.spark.mllib.util.MLUtils<br />
<br />
'''val '''data = MLUtils.loadLibSVMFile(sc, "logisticRegresion.txt")<br />
'''val '''splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)<br />
'''val '''training = splits(0).cache()<br />
'''val '''test = splits(1)<br />
'''val '''model = '''new '''LogisticRegressionWithLBFGS()<br />
.setNumClasses(10)<br />
.run(training)<br />
<br />
'''val '''predictionAndLabels = test.map { '''case '''LabeledPoint(label, features) =><br />
'''val '''prediction = model.predict(features)<br />
(prediction, label)<br />
}<br />
'''val '''metrics = '''new '''MulticlassMetrics(predictionAndLabels)<br />
'''val '''accuracy = metrics.accuracy<br />
println(accuracy)<br />
<br />
===Классификация при помощи MLP===<br />
{{main|Нейронные сети, перцептрон}}<br />
<br />
Sbt зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации c применением smile.classification.mlp<ref>[https://haifengl.github.io/smile/classification.html#neural-network Smile, MLP]</ref>:<br />
'''import '''smile.classification.NeuralNetwork.{ActivationFunction, ErrorFunction}<br />
'''import '''smile.data.{AttributeDataset, NumericAttribute}<br />
'''import '''smile.read<br />
'''import '''smile.classification.mlp<br />
'''import '''smile.plot.plot<br />
<br />
'''val '''data: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = data.x()<br />
'''val '''y: Array['''Int'''] = data.y().map(_.toInt)<br />
'''val '''mlpModel = mlp(x, y, Array(2, 10, 2), ErrorFunction.LEAST_MEAN_SQUARES, ActivationFunction.LOGISTIC_SIGMOID)<br />
plot(x, y, mlpModel)<br />
<br />
===Рекуррентные нейронные сети===<br />
{{main|Рекуррентные нейронные сети}}<br />
<br />
Пример кода, с использованием библиотеки DeepLearning.scala<br />
<span style="color:#3D9970>// Задание слоёв</span><br />
'''def '''tanh(x: INDArrayLayer): INDArrayLayer = {<br />
'''val '''exp_x = hyperparameters.exp(x)<br />
'''val '''exp_nx = hyperparameters.exp(-x)<br />
(exp_x - exp_nx) / (exp_x + exp_nx)<br />
}<br />
'''def '''charRNN(x: INDArray, y: INDArray, hprev: INDArrayLayer): (DoubleLayer, INDArrayLayer, INDArrayLayer) = {<br />
'''val '''hnext = tanh(wxh.dot(x) + whh.dot(hprev) + bh)<br />
'''val '''yraw = why.dot(hnext) + by<br />
'''val '''yraw_exp = hyperparameters.exp(yraw)<br />
'''val '''prob = yraw_exp / yraw_exp.sum<br />
'''val '''loss = -hyperparameters.log((prob * y).sum)<br />
(loss, prob, hnext)<br />
}<br />
<br />
<span style="color:#3D9970>// Определение структуры</span><br />
'''val '''batches = data.zip(data.tail).grouped(seqLength).toVector<br />
type WithHiddenLayer[A] = (A, INDArrayLayer)<br />
type Batch = IndexedSeq[(Char, Char)]<br />
type Losses = Vector['''Double''']<br />
'''def '''singleBatch(batch: WithHiddenLayer[Batch]): WithHiddenLayer[DoubleLayer] = {<br />
batch '''match '''{<br />
'''case '''(batchseq, hprev) => batchseq.foldLeft((DoubleLayer(0.0.forward), hprev)) {<br />
(bstate: WithHiddenLayer[DoubleLayer], xy: (Char, Char)) =><br />
(bstate, xy) '''match '''{<br />
'''case '''((tot, localhprev), (x, y)) => {<br />
charRNN(oneOfK(x), oneOfK(y), localhprev) '''match '''{<br />
'''case '''(localloss, _, localhnext) => {<br />
(tot + localloss, localhnext)<br />
}<br />
}<br />
}<br />
}<br />
}<br />
}<br />
}<br />
<br />
<span style="color:#3D9970>// Определение одного шага обучения</span><br />
'''def '''initH = INDArrayLayer(Nd4j.zeros(hiddenSize, 1).forward)<br />
'''def '''singleRound(initprevloss: Losses): Future[Losses] =<br />
(batches.foldLeftM((initprevloss, initH)) {<br />
(bstate: WithHiddenLayer[Losses], batch: Batch) =><br />
bstate '''match '''{<br />
'''case '''(prevloss, hprev) => singleBatch(batch, hprev) '''match '''{<br />
'''case '''(bloss, hnext) => bloss.train.map {<br />
(blossval: '''Double''') => {<br />
'''val '''nloss = prevloss.last * 0.999 + blossval * 0.001<br />
'''val '''loss_seq = prevloss :+ prevloss.last * 0.999 + blossval * 0.001<br />
(loss_seq, hnext)<br />
}<br />
}<br />
}<br />
}<br />
}).map {<br />
(fstate: WithHiddenLayer[Losses]) =><br />
fstate '''match '''{<br />
'''case '''(floss, _) => floss<br />
}<br />
}<br />
'''def '''allRounds: Future[Losses] = (0 until 2048).foldLeftM(Vector(-math.log(1.0 / vocabSize) * seqLength)) {<br />
(ploss: Losses, round: '''Int''') => {<br />
singleRound(ploss)<br />
}<br />
}<br />
<br />
<span style="color:#3D9970>// Обучение сети</span><br />
'''def '''unsafePerformFuture[A](f: Future[A]): A = Await.result(f.toScalaFuture, Duration.Inf)<br />
'''val '''losses = unsafePerformFuture(allRounds)<br />
<br />
===Долгая краткосрочная память===<br />
Основная статья: [[Долгая краткосрочная память]].<br />
<br />
[https://github.com/IlyaHalsky/neerc-wiki-ml-scala/blob/master/lstm/GravesLSTMCharModellingExample.scala Пример реализации LSTM] на основе DeepLearning4j<ref>[https://deeplearning4j.org/ DeepLearning4j]</ref> и ND4J<ref>[https://deeplearning4j.org/docs/latest/nd4j-overview ND4J]</ref><br />
<br />
===Обработка естественного языка===<br />
Основная статья: [[Обработка естественного языка#Пример кода на языке Scala | Обработка естественного языка: Пример кода на языке Scala]].<br />
<br />
===Метрический классификатор и метод ближайших соседей===<br />
Освновная статья: [[Метрический классификатор и метод ближайших соседей#Пример на языке Scala | Метрический классификатор и метод ближайших соседей: Пример на языке Scala]].<br />
<br />
===Метод опорных векторов===<br />
Освновная статья: [[Метод опорных векторов (SVM)]]<sup>[на 28.01.19 не создан]</sup>.<br />
<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.svm<ref>[https://haifengl.github.io/smile/classification.html#svm Smile, SVM]</ref>:<br />
'''import '''smile.classification._<br />
'''import '''smile.data._<br />
'''import '''smile.plot._<br />
'''import '''smile.read<br />
'''import '''smile.validation.FMeasure<br />
<br />
'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = iris.x()<br />
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)<br />
'''val '''SVM = svm(x, y, '''new '''GaussianKernel(8.0), 100)<br />
'''val '''predictions: Array['''Int'''] = x.map(SVM.predict)<br />
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)<br />
plot(x, y, SVM)<br />
<br />
===Дерево решений и случайный лес===<br />
Основная статья: [[Дерево решений и случайный лес#Пример на языке Scala | Дерево решений и случайный лес: Пример на языке Scala]].<br />
<br />
===Байесовская классификация===<br />
Основная статья: [[Байесовская классификация]]<sup>[на 28.01.19 не создан]</sup>.<br />
<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.tsukaby" '''%%''' "naive-bayes-classifier-scala" '''%''' "0.2.0"<br />
Пример классификации используя smile.classification.cart<ref>[https://github.com/tsukaby/naive-bayes-classifier-scala Naive bayes classifier, Scala]</ref>:<br />
<span style="color:#3D9970>// Создание модели</span><br />
'''val '''bayes = '''new '''BayesClassifier[String, String]()<br />
<span style="color:#3D9970>// Задание соотвествия категория - слово</span><br />
bayes.learn("technology", "github" :: "git" :: "tech" :: "technology" :: Nil)<br />
bayes.learn("weather", "sun" :: "rain" :: "cloud" :: "weather" :: "snow" :: Nil)<br />
bayes.learn("government", "ballot" :: "winner" :: "party" :: "money" :: "candidate" :: Nil)<br />
<span style="color:#3D9970>// Тестовые примеры</span><br />
'''val '''unknownText1 = "I use git".split(" ")<br />
'''val '''unknownText2 = "Today's weather is snow".split(" ")<br />
'''val '''unknownText3 = "I will vote '''for '''that party".split(" ")<br />
<span style="color:#3D9970>// Классификация</span><br />
println(bayes.classify(unknownText1).map(_.category).getOrElse("")) <span style="color:#3D9970>// technology</span><br />
println(bayes.classify(unknownText2).map(_.category).getOrElse("")) <span style="color:#3D9970>// weather</span><br />
println(bayes.classify(unknownText3).map(_.category).getOrElse("")) <span style="color:#3D9970>// government</span><br />
<br />
===EM-алгоритм===<br />
Основная статья: [[EM-алгоритм]]<sup>[на 28.01.19 не создан]</sup>.<br />
<br />
SBT зависимость:<br />
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"<br />
Пример классификации используя smile.clustering.kmeans<ref>[https://haifengl.github.io/smile/clustering.html#k-means Smile, K-Means]</ref>:<br />
'''import '''smile.clustering._<br />
'''import '''smile.data._<br />
'''import '''smile.plot._<br />
'''import '''smile.read<br />
<br />
'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))<br />
'''val '''x: Array[Array['''Double''']] = iris.x()<br />
'''val '''kMeans: KMeans = kmeans(x, k = 6, maxIter = 1000)<br />
'''val '''y = kMeans.getClusterLabel<br />
plot(x, y, '.', Palette.COLORS)<br />
<br />
===Бустинг, AdaBoost===<br />
Основная статья: [[Бустинг, AdaBoost#Пример на языке Scala | Бустинг, AdaBoost: Пример на языке Scala]].<br />
<br />
===Уменьшение размерности===<br />
Основная статья: [[Уменьшение размерности#Пример на языке Scala | Уменьшение размерности: Пример на языке Scala]].<br />
<br />
== Примечания ==<br />
<references/><br />
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D0%B7%D0%BE%D1%80_%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA_%D0%B4%D0%BB%D1%8F_%D0%BC%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BD%D0%B0_Python&diff=69666Обзор библиотек для машинного обучения на Python2019-01-30T19:15:48Z<p>Dariyakovleva: </p>
<hr />
<div>[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]<br />
<br />
==Scikit-learn==<br />
===Описание===<br />
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]]<sup>[на 28.01.19 не создан]</sup>. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]]<sup>[на 28.01.19 не создан]</sup> и её модификаций Лассо, гребневой регрессии, [[Метод опорных векторов (SVM)|опорных векторов]]<sup>[на 28.01.19 не создан]</sup>, [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]]<sup>[на 28.01.19 не создан]</sup>. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.<br />
<br />
===Примеры кода===<br />
====Линейная регрессия====<br />
{{Main|Линейная регрессия|l1=Линейная регрессия<sup>[на 28.01.19 не создан]</sup>}}<br />
<br />
<font color="green"># Add required imports</font><br />
'''import''' matplotlib.pyplot '''as''' plt<br />
'''import''' numpy '''as''' np<br />
'''from''' sklearn '''import''' datasets<br />
'''from''' sklearn.linear_model '''import''' LinearRegression<br />
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score<br />
<br />
Загрузка датасета:<br />
diabetes = datasets.load_diabetes()<br />
<font color="green"># Use only one feature</font><br />
diabetes_X = diabetes.data[:, np.newaxis, <font color="blue">2</font>]<br />
<br />
Разбиение датасета на тренировочный и тестовый:<br />
<font color="green"># Split the data into training/testing sets</font><br />
x_train = diabetes_X[:<font color="blue">-20</font>]<br />
x_test = diabetes_X[<font color="blue">-20</font>:]<br />
<br />
<font color="green"># Split the targets into training/testing sets</font><br />
y_train = diabetes.target[:<font color="blue">-20</font>]<br />
y_test = diabetes.target[<font color="blue">-20</font>:]<br />
<br />
Построение и обучение модели:<br />
lr = LinearRegression()<br />
lr.fit(x_train, y_train)<br />
predictions = lr.predict(x_test)<br />
<br />
Оценка алгоритма:<br />
<font color="green"># The mean squared error</font><br />
print(<font color="red">"Mean squared error: %.2f"</font><br />
% mean_squared_error(y_test, predictions))<br />
<font color="green"># Explained variance score: 1 is perfect prediction</font><br />
print(<font color="red">'Variance score: %.2f'</font> % r2_score(y_test, predictions))<br />
<br />
> '''Mean squared error: 2548.07'''<br />
'''Variance score: 0.47'''<br />
<br />
Построение графика прямой, получившейся в результате работы линейной регрессии:<br />
plt.scatter(x_test, y_test, color=<font color="red">'black'</font>)<br />
plt.plot(x_test, predictions, color=<font color="red">'blue'</font>, linewidth=<font color="blue">3</font>)<br />
plt.xticks(())<br />
plt.yticks(())<br />
plt.show()<br />
<br />
[[File:Diabetes-sklearn.png|400px|none|super]]<br />
<br />
====Логистическая регрессия====<br />
{{Main|Логистическая регрессия}}<br />
<br />
Загрузка датасета:<br />
'''from''' sklearn.datasets '''import''' load_digits<br />
digits = load_digits()<br />
<br />
Вывод первых трех тренировочных данных для визуализации:<br />
'''import''' numpy '''as''' np<br />
'''import''' matplotlib.pyplot '''as''' plt<br />
<br />
plt.figure(figsize=(<font color="blue">20</font>,<font color="blue">4</font>))<br />
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[<font color="blue">0</font>:<font color="blue">3</font>], digits.target[<font color="blue">0</font>:<font color="blue">3</font>])):<br />
plt.subplot(<font color="blue">1</font>, <font color="blue">3</font>, index + <font color="blue">1</font>)<br />
plt.imshow(np.reshape(image, (<font color="blue">8</font>,<font color="blue">8</font>)), cmap=plt.cm.gray)<br />
plt.title(<font color="red">'Training: %i\n'</font> % label, fontsize = <font color="blue">20</font>)<br />
<br />
[[File:Digits-sklearn.png|800px|none|super]]<br />
<br />
Разбиение датасета на тренировочный и тестовый:<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=<font color="blue">0.25</font>, random_state=<font color="blue">0</font>)<br />
<br />
Построение и обучение модели:<br />
'''from''' sklearn.linear_model '''import''' LogisticRegression<br />
lr = LogisticRegression()<br />
lr.fit(x_train, y_train)<br />
predictions = lr.predict(x_test)<br />
<br />
Оценка алгоритма:<br />
score = lr.score(x_test, y_test)<br />
print(<font color="red">"Score: %.3f"</font> % score)<br />
<br />
> '''Score: 0.953'''<br />
<br />
====Перцептрон====<br />
{{Main|Нейронные сети, перцептрон}}<br />
<br />
Загрузка датасета:<br />
'''from''' sklearn '''import''' datasets<br />
iris = datasets.load_iris()<br />
X = iris.data<br />
y = iris.target<br />
<br />
Разбиение датасета на тренировочный и тестовый:<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = <font color="blue">0.20</font>)<br />
<br />
Трансформация признаков:<br />
'''from''' sklearn.preprocessing '''import''' StandardScaler<br />
scaler = StandardScaler()<br />
scaler.fit(X_train)<br />
X_train = scaler.transform(X_train)<br />
X_test = scaler.transform(X_test)<br />
<br />
Построение и обучение модели:<br />
'''from''' sklearn.neural_network '''import''' MLPClassifier<br />
mlp = MLPClassifier(hidden_layer_sizes=(<font color="blue">10</font>, <font color="blue">10</font>, <font color="blue">10</font>), max_iter=<font color="blue">1000</font>)<br />
mlp.fit(X_train, y_train.values.ravel())<br />
predictions = mlp.predict(X_test)<br />
<br />
Оценка алгоритма:<br />
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix<br />
print(confusion_matrix(y_test,predictions))<br />
print(classification_report(y_test,predictions))<br />
<br />
> '''[[ 7 0 0]'''<br />
'''[ 0 8 1]'''<br />
'''[ 0 2 12]]'''<br />
'''precision recall f1-score support'''<br />
<br />
'''0 1.00 1.00 1.00 7'''<br />
'''1 0.80 0.89 0.84 9'''<br />
'''2 0.92 0.86 0.89 14'''<br />
<br />
'''micro avg 0.90 0.90 0.90 30'''<br />
'''macro avg 0.91 0.92 0.91 30'''<br />
'''weighted avg 0.90 0.90 0.90 30'''<br />
<br />
====Метрический классификатор и метод ближайших соседей====<br />
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}<br />
<br />
====Дерево решений и случайный лес====<br />
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}<br />
<br />
====Обработка естественного языка====<br />
{{Main|Обработка естественного языка}}<br />
<br />
Загрузка датасета:<br />
'''from''' sklearn '''import''' fetch_20newsgroups<br />
twenty_train = fetch_20newsgroups(subset=<font color="red">'train'</font>, shuffle='''True''', random_state=<font color="blue">42</font>)<br />
<br />
Вывод первых трех строк первого тренивочного файла и его класса:<br />
print(<font color="red">"\n"</font>.join(twenty_train.data[<font color="blue">0</font>].split(<font color="red">"\n"</font>)[:<font color="blue">3</font>]))<br />
print(twenty_train.target_names[twenty_train.target[<font color="blue">0</font>]])<br />
<br />
> '''From: lerxst@wam.umd.edu (where's my thing)'''<br />
'''Subject: WHAT car is this!?'''<br />
'''Nntp-Posting-Host: rac3.wam.umd.edu'''<br />
<br />
'''rec.autos'''<br />
<br />
Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]]<sup>[на 28.01.19 не создан]</sup>, а вторая использует метод опорных векторов:<br />
'''from''' sklearn.pipeline '''import''' Pipeline<br />
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer<br />
<br />
'''from''' sklearn.naive_bayes '''import''' MultinomialNB<br />
text_clf1 = Pipeline([<br />
(<font color="red">'vect'</font>, CountVectorizer()),<br />
(<font color="red">'tfidf'</font>, TfidfTransformer()),<br />
(<font color="red">'clf'</font>, MultinomialNB()),<br />
])<br />
<br />
'''from''' sklearn.linear_model '''import''' SGDClassifier<br />
text_clf2 = Pipeline([<br />
(<font color="red">'vect'</font>, CountVectorizer()),<br />
(<font color="red">'tfidf'</font>, TfidfTransformer()),<br />
(<font color="red">'clf'</font>, SGDClassifier(loss=<font color="red">'hinge'</font>, penalty=<font color="red">'l2'</font>,<br />
alpha=<font color="blue">1e-3</font>, random_state=<font color="blue">42</font>,<br />
max_iter=<font color="blue">5</font>, tol='''None''')),<br />
])<br />
<br />
text_clf1.fit(twenty_train.data, twenty_train.target)<br />
text_clf2.fit(twenty_train.data, twenty_train.target)<br />
<br />
Оценка алгоритмов:<br />
twenty_test = fetch_20newsgroups(subset=<font color="red">'test'</font>, shuffle='''True''', random_state=<font color="blue">42</font>)<br />
docs_test = twenty_test.data<br />
predicted1 = text_clf1.predict(docs_test)<br />
predicted2 = text_clf2.predict(docs_test)<br />
print(<font color="red">"Score: %.3f"</font> % np.mean(predicted1 == twenty_test.target))<br />
print(<font color="red">"Score: %.3f"</font> % np.mean(predicted2 == twenty_test.target))<br />
<br />
> '''Score for naive Bayes: 0.774'''<br />
'''Score for SVM: 0.824'''<br />
<br />
====Кросс-валилация и подбор параметров====<br />
{{Main|Кросс-валидация}}<br />
<br />
Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:<br />
'''from''' sklearn.model_selection '''import''' GridSearchCV<br />
parameters = {<br />
<font color="red">'vect__ngram_range'</font>: [(<font color="blue">1</font>, <font color="blue">1</font>), (<font color="blue">1</font>, <font color="blue">2</font>)],<br />
<font color="red">'tfidf__use_idf'</font>: ('''True''', '''False'''),<br />
<font color="red">'clf__alpha'</font>: (<font color="blue">1e-2</font>, <font color="blue">1e-3</font>),<br />
}<br />
<br />
gs_clf = GridSearchCV(text_clf2, parameters, cv=<font color="blue">5</font>, iid='''False''', n_jobs=<font color="blue">-1</font>)<br />
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)<br />
<br />
print(<font color="red">"Best score: %.3f"</font> % gs_clf.best_score_)<br />
<br />
'''for''' param_name '''in''' sorted(parameters.keys()):<br />
print(<font color="red">"%s: %r"</font> % (param_name, gs_clf.best_params_[param_name]))<br />
<br />
> '''Best score: 0.904'''<br />
'''clf__alpha: 0.001'''<br />
'''tfidf__use_idf: True'''<br />
'''vect__ngram_range: (1, 2)'''<br />
<br />
====Метод опорных векторов (SVM)====<br />
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) <sup>[на 28.01.19 не создан]</sup>}}<br />
<br />
Загрузка датасета:<br />
'''from''' sklearn '''import''' datasets<br />
iris = datasets.load_iris()<br />
<br />
Разбиение датасета на тестовый и тренировочный:<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=<font color="blue">0.25</font>, random_state=<font color="blue">0</font>)<br />
<br />
Построение и обучение модели:<br />
clf = svm.SVC(kernel=<font color="red">'linear'</font>, C=<font color="blue">1.0</font>)<br />
clf.fit(x_train, y_train)<br />
predictions = clf.predict(x_test)<br />
<br />
Оценка алгоритма:<br />
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix<br />
print(confusion_matrix(y_test,predictions))<br />
print(classification_report(y_test,predictions))<br />
<br />
> '''[[13 0 0]'''<br />
'''[ 0 15 1]'''<br />
'''[ 0 0 9]]'''<br />
'''precision recall f1-score support'''<br />
<br />
'''0 1.00 1.00 1.00 13'''<br />
'''1 1.00 0.94 0.97 16'''<br />
'''2 0.90 1.00 0.95 9'''<br />
<br />
'''micro avg 0.97 0.97 0.97 38'''<br />
'''macro avg 0.97 0.98 0.97 38'''<br />
'''weighted avg 0.98 0.97 0.97 38'''<br />
<br />
====EM-алгоритм====<br />
{{Main|EM-алгоритм|l1=EM-алгоритм<sup>[на 28.01.19 не создан]</sup>}}<br />
<br />
'''import''' numpy '''as''' np<br />
'''import''' matplotlib.pyplot '''as''' plt<br />
'''from''' matplotlib.colors '''import''' LogNorm<br />
'''from''' sklearn '''import''' mixture<br />
<br />
n_samples = <font color="blue">300</font><br />
<br />
<font color="green"># generate random sample, two components</font><br />
np.random.seed(<font color="blue">0</font>)<br />
<br />
<font color="green"># generate spherical data centered on (20, 20)</font><br />
shifted_gaussian = np.random.randn(n_samples, <font color="blue">2</font>) + np.array([<font color="blue">20</font>, <font color="blue">20</font>])<br />
<br />
<font color="green"># generate zero centered stretched Gaussian data</font><br />
C = np.array([[<font color="blue">0.</font>, <font color="blue">-0.7</font>], [<font color="blue">3.5</font>, <font color="blue">.7</font>]])<br />
stretched_gaussian = np.dot(np.random.randn(n_samples, <font color="blue">2</font>), C)<br />
<br />
<font color="green"># concatenate the two datasets into the final training set</font><br />
X_train = np.vstack([shifted_gaussian, stretched_gaussian])<br />
<br />
<font color="green"># fit a Gaussian Mixture Model with two components</font><br />
clf = mixture.GaussianMixture(n_components=<font color="blue">2</font>, covariance_type=<font color="red">'full'</font>)<br />
clf.fit(X_train)<br />
<br />
<font color="green"># display predicted scores by the model as a contour plot</font><br />
x = np.linspace(<font color="blue">-20.</font>, <font color="blue">30.</font>)<br />
y = np.linspace(<font color="blue">-20.</font>, <font color="blue">40.</font>)<br />
X, Y = np.meshgrid(x, y)<br />
XX = np.array([X.ravel(), Y.ravel()]).T<br />
Z = -clf.score_samples(XX)<br />
Z = Z.reshape(X.shape)<br />
<br />
CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=<font color="blue">1.0</font>, vmax=<font color="blue">1000.0</font>),<br />
levels=np.logspace(<font color="blue">0</font>, <font color="blue">3</font>, <font color="blue">10</font>))<br />
CB = plt.colorbar(CS, shrink=<font color="blue">0.8</font>, extend=<font color="red">'both'</font>)<br />
plt.scatter(X_train[:, <font color="blue">0</font>], X_train[:, <font color="blue">1</font>], <font color="blue">.8</font>)<br />
<br />
plt.title(<font color="red">'Negative log-likelihood predicted by a GMM'</font>)<br />
plt.axis(<font color="red">'tight'</font>)<br />
plt.show()<br />
<br />
[[File:Em.png|400px|none|super]]<br />
<br />
====Уменьшение размерности====<br />
{{Main|Уменьшение размерности#Пример кода scikit-learn|l1=Уменьшение размерности: пример через scikit-learn}}<br />
<br />
==Tensorflow==<br />
===Описание===<br />
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.<br />
===Примеры кода===<br />
====Сверточная нейронная сеть====<br />
{{Main|Сверточные нейронные сети}}<br />
<br />
Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:<br />
'''from''' __future__ '''import''' division, print_function, absolute_import<br />
'''import''' tensorflow '''as''' tf<br />
<br />
<font color="green"># Import MNIST data</font><br />
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data<br />
mnist = input_data.read_data_sets(<font color="red">"/tmp/data/"</font>, one_hot='''True''')<br />
<br />
<font color="green"># Training Parameters</font><br />
learning_rate = <font color="blue">0.001</font><br />
num_steps = <font color="blue">200</font><br />
batch_size = <font color="blue">128</font><br />
display_step = <font color="blue">10</font><br />
<br />
<font color="green"># Network Parameters</font><br />
num_input = <font color="blue">784</font> <font color="green"># MNIST data input (img shape: 28*28)</font><br />
num_classes = <font color="blue">10</font> <font color="green"># MNIST total classes (0-9 digits)</font><br />
dropout = <font color="blue">0.75</font> <font color="green"># Dropout, probability to keep units</font><br />
<br />
<font color="green"># tf Graph input</font><br />
X = tf.placeholder(tf.float32, ['''None''', num_input])<br />
Y = tf.placeholder(tf.float32, ['''None''', num_classes])<br />
keep_prob = tf.placeholder(tf.float32) <font color="green"># dropout (keep probability)</font><br />
<br />
<font color="green"># Create some wrappers for simplicity</font><br />
'''def''' conv2d(x, W, b, strides=<font color="blue">1</font>):<br />
<font color="green"># Conv2D wrapper, with bias and relu activation</font><br />
x = tf.nn.conv2d(x, W, strides=[<font color="blue">1</font>, strides, strides, <font color="blue">1</font>], padding=<font color="red">'SAME'</font>)<br />
x = tf.nn.bias_add(x, b)<br />
'''return''' tf.nn.relu(x)<br />
<br />
'''def''' maxpool2d(x, k=<font color="blue">2</font>):<br />
<font color="green"># MaxPool2D wrapper</font><br />
'''return''' tf.nn.max_pool(x, ksize=[<font color="blue">1</font>, k, k, <font color="blue">1</font>], strides=[<font color="blue">1</font>, k, k, <font color="blue">1</font>],<br />
padding=<font color="red">'SAME'</font>)<br />
<br />
<font color="green"># Create model</font><br />
'''def''' conv_net(x, weights, biases, dropout):<br />
<font color="green"># MNIST data input is a 1-D vector of 784 features (28*28 pixels)<br />
# Reshape to match picture format [Height x Width x Channel]<br />
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]</font><br />
x = tf.reshape(x, shape=[<font color="blue">-1</font>, <font color="blue">28</font>, <font color="blue">28</font>, <font color="blue">1</font>])<br />
<font color="green"># Convolution Layer</font><br />
conv1 = conv2d(x, weights[<font color="red">'wc1'</font>], biases[<font color="red">'bc1'</font>])<br />
<font color="green"># Max Pooling (down-sampling)</font><br />
conv1 = maxpool2d(conv1, k=<font color="blue">2</font>)<br />
<font color="green"># Convolution Layer</font><br />
conv2 = conv2d(conv1, weights[<font color="red">'wc2'</font>], biases[<font color="red">'bc2'</font>])<br />
<font color="green"># Max Pooling (down-sampling)</font><br />
conv2 = maxpool2d(conv2, k=<font color="blue">2</font>)<br />
<font color="green"># Fully connected layer<br />
# Reshape conv2 output to fit fully connected layer input</font><br />
fc1 = tf.reshape(conv2, [<font color="blue">-1</font>, weights[<font color="red">'wd1'</font>].get_shape().as_list()[<font color="blue">0</font>]])<br />
fc1 = tf.add(tf.matmul(fc1, weights[<font color="red">'wd1'</font>]), biases[<font color="red">'bd1'</font>])<br />
fc1 = tf.nn.relu(fc1)<br />
<font color="green"># Apply Dropout</font><br />
fc1 = tf.nn.dropout(fc1, dropout)<br />
<font color="green"># Output, class prediction</font><br />
out = tf.add(tf.matmul(fc1, weights[<font color="red">'out'</font>]), biases[<font color="red">'out'</font>])<br />
'''return''' out<br />
<br />
<font color="green"># Store layers weight & bias</font><br />
weights = {<br />
<font color="green"># 5x5 conv, 1 input, 32 outputs</font><br />
<font color="red">'wc1'</font>: tf.Variable(tf.random_normal([<font color="blue">5</font>, <font color="blue">5</font>, <font color="blue">1</font>, <font color="blue">32</font>])),<br />
<font color="green"># 5x5 conv, 32 inputs, 64 outputs</font><br />
<font color="red">'wc2'</font>: tf.Variable(tf.random_normal([<font color="blue">5</font>, <font color="blue">5</font>, <font color="blue">32</font>, <font color="blue">64</font>])),<br />
<font color="green"># fully connected, 7*7*64 inputs, 1024 outputs</font><br />
<font color="red">'wd1'</font>: tf.Variable(tf.random_normal([<font color="blue">7</font>*<font color="blue">7</font>*<font color="blue">64</font>, <font color="blue">1024</font>])),<br />
<font color="green"># 1024 inputs, 10 outputs (class prediction)</font><br />
<font color="red">'out'</font>: tf.Variable(tf.random_normal([<font color="blue">1024</font>, num_classes]))<br />
}<br />
<br />
biases = {<br />
<font color="red">'bc1'</font>: tf.Variable(tf.random_normal([<font color="blue">32</font>])),<br />
<font color="red">'bc2'</font>: tf.Variable(tf.random_normal([<font color="blue">64</font>])),<br />
<font color="red">'bd1'</font>: tf.Variable(tf.random_normal([<font color="blue">1024</font>])),<br />
<font color="red">'out'</font>: tf.Variable(tf.random_normal([num_classes]))<br />
}<br />
<br />
<font color="green"># Construct model</font><br />
logits = conv_net(X, weights, biases, keep_prob)<br />
prediction = tf.nn.softmax(logits)<br />
<br />
<font color="green"># Define loss and optimizer</font><br />
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(<br />
logits=logits, labels=Y))<br />
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)<br />
train_op = optimizer.minimize(loss_op)<br />
<br />
<font color="green"># Evaluate model</font><br />
correct_pred = tf.equal(tf.argmax(prediction, <font color="blue">1</font>), tf.argmax(Y, <font color="blue">1</font>))<br />
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))<br />
<br />
<font color="green"># Initialize the variables (i.e. assign their default value)</font><br />
init = tf.global_variables_initializer()<br />
<br />
<font color="green"># Start training</font><br />
'''with''' tf.Session() '''as''' sess:<br />
<font color="green"># Run the initializer</font><br />
sess.run(init)<br />
'''for''' step '''in''' '''range'''(<font color="blue">1</font>, num_steps+<font color="blue">1</font>):<br />
batch_x, batch_y = mnist.train.next_batch(batch_size)<br />
<font color="green"># Run optimization op (backprop)</font><br />
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: <font color="blue">0.8</font>})<br />
'''if''' step % display_step == <font color="blue">0</font> '''or''' step == <font color="blue">1</font>:<br />
<font color="green"># Calculate batch loss and accuracy</font><br />
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,<br />
Y: batch_y,<br />
keep_prob: <font color="blue">1.0</font>})<br />
print(<font color="red">"Step "</font> + str(step) + <font color="red">", Minibatch Loss= "</font> + \<br />
<font color="red">"{:.4f}"</font>.format(loss) + <font color="red">", Training Accuracy= "</font> + \<br />
<font color="red">"{:.3f}"</font>.format(acc))<br />
print(<font color="red">"Optimization Finished!"</font>)<br />
<font color="green"># Calculate accuracy for 256 MNIST test images</font><br />
print(<font color="red">"Testing Accuracy:"</font>, \<br />
sess.run(accuracy, feed_dict={X: mnist.test.images[:<font color="blue">256</font>],<br />
Y: mnist.test.labels[:<font color="blue">256</font>],<br />
keep_prob: <font color="blue">1.0</font>}))<br />
<br />
> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''<br />
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''<br />
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''<br />
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''<br />
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''<br />
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''<br />
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''<br />
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''<br />
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''<br />
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''<br />
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''<br />
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''<br />
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''<br />
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''<br />
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''<br />
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''<br />
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''<br />
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''<br />
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''<br />
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''<br />
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''<br />
'''Optimization Finished!'''<br />
'''Testing Accuracy: 0.94140625'''<br />
<br />
==Keras==<br />
===Описание===<br />
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.<br />
===Примеры кода===<br />
====Сверточная нейронная сеть====<br />
{{Main|Сверточные нейронные сети}}<br />
<br />
Реализация сверточной нейронной сети для классификации текста:<br />
'''from''' __future__ '''import''' print_function<br />
'''from''' keras.preprocessing '''import''' sequence<br />
'''from''' keras.models '''import''' Sequential<br />
'''from''' keras.layers '''import''' Dense, Dropout, Activation<br />
'''from''' keras.layers '''import''' Embedding<br />
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D<br />
'''from''' keras.datasets '''import''' imdb<br />
<br />
<font color="green"># set parameters:</font><br />
max_features = <font color="blue">5000</font><br />
maxlen = <font color="blue">400</font><br />
batch_size = <font color="blue">32</font><br />
embedding_dims = <font color="blue">50</font><br />
filters = <font color="blue">250</font><br />
kernel_size = <font color="blue">3</font><br />
hidden_dims = <font color="blue">250</font><br />
epochs = <font color="blue">2</font><br />
<br />
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)<br />
print(len(x_train), <font color="red">'train sequences'</font>)<br />
print(len(x_test), <font color="red">'test sequences'</font>)<br />
<br />
> '''25000 train sequences'''<br />
'''25000 test sequences'''<br />
<br />
print(<font color="red">'Pad sequences (samples x time)'</font>)<br />
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)<br />
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)<br />
print(<font color="red">'x_train shape:'</font>, x_train.shape)<br />
print(<font color="red">'x_test shape:'</font>, x_test.shape)<br />
<br />
> '''Pad sequences (samples x time)'''<br />
'''x_train shape: (25000, 400)'''<br />
'''x_test shape: (25000, 400)'''<br />
<br />
model = Sequential()<br />
<br />
model.add(Embedding(max_features,<br />
embedding_dims,<br />
input_length=maxlen))<br />
model.add(Dropout(<font color="blue">0.2</font>)) <br />
model.add(Conv1D(filters,<br />
kernel_size,<br />
padding=<font color="red">'valid'</font>,<br />
activation=<font color="red">'relu'</font>,<br />
strides=<font color="blue">1</font>))<br />
model.add(GlobalMaxPooling1D())<br />
model.add(Dense(hidden_dims))<br />
model.add(Dropout(<font color="blue">0.2</font>))<br />
model.add(Activation(<font color="red">'relu'</font>))<br />
model.add(Dense(<font color="blue">1</font>))<br />
model.add(Activation(<font color="red">'sigmoid'</font>))<br />
<br />
model.compile(loss=<font color="red">'binary_crossentropy'</font>,<br />
optimizer=<font color="red">'adam'</font>,<br />
metrics=[<font color="red">'accuracy'</font>])<br />
model.fit(x_train, y_train,<br />
batch_size=batch_size,<br />
epochs=epochs,<br />
validation_data=(x_test, y_test))<br />
<br />
> '''Train on 25000 samples, validate on 25000 samples'''<br />
'''Epoch 1/2'''<br />
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''<br />
'''Epoch 2/2'''<br />
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''<br />
<br />
==Другие библиотеки для машинного обучения на Python==<br />
===Вспомогательные библиотеки===<br />
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>;<br />
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке;<br />
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib;<br />
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.<br />
<br />
===Библиотеки для глубокого обучения===<br />
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff;<br />
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач;<br />
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA;<br />
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.<br />
<br />
===Библиотеки для обработки естественного языка===<br />
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python;<br />
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.<br />
<br />
===Библиотеки для градиентного бустинга===<br />
* [[XGBoost|Xgboost]]<sup>[на 28.01.19 не создан]</sup><ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм;<br />
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net;<br />
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.<br />
<br />
==См. также==<br />
*[[:Примеры кода на Scala|Примеры кода на Scala]]<br />
*[[:Примеры кода на R|Примеры кода на R]]<sup>[на 28.01.19 не создан]</sup><br />
*[[:Примеры кода на Java|Примеры кода на Java]]<sup>[на 28.01.19 не создан]</sup><br />
<br />
==Примечания==<br />
<references/><br />
<br />
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=CatBoost&diff=69665CatBoost2019-01-30T19:09:18Z<p>Dariyakovleva: </p>
<hr />
<div>Библиотека CatBoost {{---}} метод машинного обучения, основанный на градиентном бустинге (англ. ''gradient boosting'').<br />
<br />
<br />
Практически любой современный метод на основе градиентного бустинга работает с числовыми признаками. Если у нас в наборе данных присутствуют не только числовые, но и категориальные признаки (англ. ''categorical features''), то необходимо переводить категориальные признаки в числовые. Это приводит к искажению их сути и потенциальному снижению точности работы модели.<br />
Именно поэтому было важно разработать алгоритм, который умеет работать не только с числовыми признаками, но и с категориальными напрямую, закономерности между которыми этот алгоритм будет выявлять самостоятельно, без ручной «помощи».<br />
CatBoost {{---}} библиотека для градиентного бустинга, главным преимуществом которой является то, что она одинаково хорошо работает «из коробки» как с числовыми признаками, так и с категориальными. <br />
<br />
Документацию по CatBoost можно найти на сайте<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/ Документация CatBoost]</ref>.<br />
<br />
----<br />
== Общий принцип работы ==<br />
<br />
=== Дерево решений ===<br />
<br />
<br />
Алгоритм работы следующий: для каждого документа имеется набор значений признаков, имеется дерево, в вершинах дерева {{---}} условия. Если условие выполнено, осуществляется переход в правого ребенка вершины, иначе в левого. Нужно пройти до листа по дереву в соответствии со значениями признаков для документа. На выходе каждому документу соответствует значение листа. Это и есть ответ.<br />
<br />
=== Бустинг ===<br />
<br />
<br />
Идея бустинг-подхода заключается в комбинации слабых (с невысокой обобщающей способностью) функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Результирующая функция представляет собой линейную комбинацию базовых, слабых моделей. Более подробно можно посмотреть в статье про градиентный бустинг<ref>[https://en.wikipedia.org/wiki/Gradient_boosting |Gradient Boosting, Wikipedia]</ref>.<br />
<br />
Далее будет рассматриваться бустинг деревьев решений. Будем строить несколько деревьев, чтобы добавление новых деревьев уменьшало ошибку. Итого при достаточно большом количестве деревьев мы сможем сильно уменьшить ошибку, однако не стоит забывать, что чем больше деревьев, тем дольше обучается модель и в какой-то момент прирост качества становится незначительным.<br />
<br />
=== Градиентный бустинг ===<br />
<br />
* В основе CatBoost лежит градиентный бустинг.<br />
<br />
* Градиент функции ошибки {{---}} все производные по всем значениям функции<br />
Градиентный бустинг {{---}} метод машинного обучения, который создает решающую модель прогнозирования в виде ансамбля слабых моделей прогнозирования, обычно деревьев решений. Он строит модель поэтапно, позволяя оптимизировать произвольную дифференцируемую функцию потерь.<br />
<br />
== Особенности CatBoost ==<br />
<br />
=== Режимы работы ===<br />
<br />
* Регрессия (англ. ''regression''); <br />
* Классификация (англ. ''classification'');<br />
Функция потерь (англ. ''loss function'') {{---}} максимизируем вероятность того, что все объекты в обучающей выборке классифицированы правильно, вероятность - это сигмоида над значением формулы.<br />
Функция ''predict_proba'' {{---}} на выходе получаем готовые вероятности. Нужно отметить, что складывать их уже нельзя.<br />
Функция ''predict'' {{---}} выдает необработанный результат. Такой результат можно складывать, например, с результатами других моделей.<br />
* Мультиклассификация (англ. ''multiclass classification'');<br />
* Ранжирование (англ. ''ranking'').<br />
Объекты с попарной классификацией (??)<br />
<br />
=== Метрики ===<br />
<br />
Поддерживает множество [[Оценка_качества_в_задачах_классификации_и_регрессии|метрик]]<sup>[на 28.01.19 не создан]</sup> (англ. ''metrics''), таких как:<br />
* Регрессия: ''MAE, MAPE, RMSE, SMAPE'' etc.;<br />
* Классификация: ''Logloss , Precision, Recall, F1, CrossEntropy, BalancedAccuracy'' etc.;<br />
* Мультиклассификация: ''MultiClass, MultiClassOneVsAll, HammingLoss, F1'' etc.;<br />
* Ранжирование: ''NDCG, PrecisionAt, RecallAt, PFound, PairLogit'' etc.<br />
<br />
== Обучение ==<br />
=== Шаги обучения ===<br />
<br />
* Строим дерево;<br />
* Считаем значение в листьях.<br />
<br />
=== Построение дерева ===<br />
<br />
Процесс построения происходит жадно. <br />
<br />
* Выбираем первую вершину;<br />
* Выбираем лучшее дерево с одной вершиной; <br />
* Считаем метрику и по ней выбираем лучшее дерево.<br />
<br />
Дерево строится по слоям. Гарантировано на каждом слое один и тот же сплит (условие по которому мы делим).<br />
<br />
=== Вычисление значений в листьях === <br />
Во время вычисления значений в листьях можем позволить себе сделать больше операций, так как у нас уже зафиксирована структура дерева и значения в листьях будут вычислены единожды. Поэтому можем себе позволить даже сделать несколько шагов по градиенту или применить метод Ньютона.<br />
<br />
=== Как выбрать лучшее дерево? ===<br />
<br />
Смотрим, на сколько меняется функция ошибки, выбираем такое дерево, чтобы оно как можно лучше приближало вектор градиентов.<br />
<br />
=== Как работает градиентный бустинг? ===<br />
<br />
Отметим, что существует идеальный шаг по градиенту, однако листьев в дереве меньше, чем документов в датасете.<br />
Поэтому мы можем пытаться приближать тот самый идеальный шаг.<br />
Чтобы найти лучший сплит, проверяем похожесть после одного шага алгоритма по градиенту.<br />
<br />
=== Рандомизация ===<br />
<br />
Есть рандомизация метрики, по которой выбирается лучшее дерево. <br />
''Score += random_strength * Rand (0, lenofgrad * q)'' <br />
<br />
''q'' {{---}} множитель, уменьшающийся при увеличении итерации. <br />
Таким образом, рандом уменьшается ближе к концу.<br />
<br />
----<br />
<br />
== Работа с датасетом ==<br />
<br />
=== Режимов выборки данных ===<br />
<br />
CatBoost поддерживает несколько режимов выборки данных<br />
<br />
* Бутстрап (англ. ''bootstrap'') Бернулли {{---}} выбираем документ с вероятностью ''p''. Регулируется параметром ''sample_rate'';<br />
* Байесовский бутстрап {{---}} байесовское распределение. Регулируется параметром ''bagging_temp''.<br />
<br />
Отметим, что бутстрап используется только для выбора структуры дерева, для подсчета значения в листьях используем всю выборку. Это сделано, так как выбор структуры дерева происходит долго, нужно несколько раз пересчитывать значения, поэтому использовать всю выборку слишком дорого. Однако значения в листьях с уже готовой структурой дерева считаются один раз, и для большей точности можно позволить использовать весь датасет.<br />
<br />
=== Бинаризация признаков ===<br />
<br />
Пробовать все {{---}} долго. Поэтому выбираем сетку заранее и ходим по ней.<br />
<br />
Есть несколько способов выбора:<br />
<br />
* Uniform. Равномерно разбиваем отрезок от минимума значения для данного признака до максимума;<br />
* Медианная сетка. Задаем количество разбиений над множеством значений, далее идем по объектам в порядке сортировки и разбиваем на группы по k объектов, где k {{---}} количество объектов в одном слоте разбиения;<br />
* UniformAndQuantiles. Комбинация 1 и 2 пунктов;<br />
* MaxSumLog {{---}} в основе лежит динамика, работает долго;<br />
* GreedyLogSum {{---}} аналог MaxSumLog, используется жадный алгоритм, поэтому работает не точно, однако быстрее чем MaxSumLog.<br />
<br />
=== Работа с категориальными признаками ===<br />
<br />
* LabelEncoding {{---}} на реальных примерах точность работы низкая, так как появляется отношения порядка между объектами;<br />
* One-hot encoding {{---}} дает неплохую точность, если различных значений признаков не много. Иначе один признак размножится на множество признаков и будет влиять на модель заведомо сильнее остальных признаков.<br />
<br />
Лучше не делать препроцессинг самим из-за проблем, описанных выше. В CatBoost можно задать параметр cat_features, передав туда индексы категориальных признаков. Также можно отрегулировать параметр ''one_hot_max_size'' {{---}} максимальное количество различных значений у категориального признака, чтобы он мог в последствии быть подвержен one-hot encoding.<br />
<br />
== Подбор параметров ==<br />
<br />
Ниже описаны гиперпараметры (англ. ''hyperparameters''), на которые стоит обратить внимание при использовании библиотеки.<br />
<br />
* cat_features;<br />
* Overfitting detector;<br />
* Число итераций и learning rate;<br />
* L2_reg;<br />
* Random_srength;<br />
* Bagging_temp;<br />
* Глубина дерева (стоит попробовать 10 и 6).<br />
<br />
== Полезная функциональность ==<br />
<br />
* Snapshots;<br />
* Overfitting detector;<br />
* CV;<br />
* eval_metrics.<br />
<br />
== Бенчмарки ==<br />
<br />
Сравнение библиотеки CatBoost с открытыми аналогами XGBoost, LightGBM и H20 на наборе публичных датасетов<ref>[https://catboost.yandex/#benchmark| Benchmarks]</ref>.<br />
<br />
== Пример использования ==<br />
* Делим данные на тренировочное и тестовое множество<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
X_train, X_validation, y_train, y_validation = train_test_split(X, y, '''train_size'''=0.5, '''random_state'''=1234)<br />
'''print'''(X_train.shape, X_validation.shape)<br />
<br />
* Создаем классификатор<br />
'''from''' catboost '''import''' CatBoostClassifier<br />
<br />
best_model = CatBoostClassifier(<br />
'''bagging_temperature'''=1,<br />
'''random_strength'''=1,<br />
'''thread_count'''=3,<br />
'''iterations'''=500,<br />
'''l2_leaf_reg''' = 4.0, <br />
'''learning_rate''' = 0.07521709965938336,<br />
'''save_snapshot'''=True,<br />
'''snapshot_file'''='snapshot_best.bkp',<br />
'''random_seed'''=63,<br />
'''od_type'''='Iter',<br />
'''od_wait'''=20,<br />
'''custom_loss'''=['AUC', 'Accuracy'],<br />
'''use_best_model'''=True<br />
)<br />
<br />
* Обучаемся<br />
<br />
best_model.fit(<br />
X_train, y_train,<br />
'''cat_features'''=cat_features,<br />
'''eval_set'''=(X_validation, y_validation),<br />
'''logging_level'''='Silent',<br />
'''plot'''=True<br />
)<br />
<br />
* Вывод числа деревьев в модели<br />
<br />
'''print'''('Resulting tree count:', best_model.tree_count_)<br />
<br />
> '''Resulting tree count: 217'''<br />
<br />
* Используем скользящий контроль (англ. cross validation)<br />
'''from''' catboost '''import''' cv<br />
<br />
params = best_model.get_params()<br />
params['iterations'] = 10<br />
params['custom_loss'] = 'AUC'<br />
del params['use_best_model']<br />
pool1 = Pool(X, '''label'''=y, '''cat_features'''=cat_features)<br />
<br />
cv_data = cv(<br />
'''params''' = params,<br />
'''pool''' = pool1,<br />
'''fold_count'''=2,<br />
'''inverted'''=False,<br />
'''shuffle'''=True,<br />
'''stratified'''=False,<br />
'''partition_random_seed'''=0<br />
)<br />
<br />
* Выводим результат<br />
best_value = np.max(cv_data['AUC_test_avg'])<br />
best_iter = np.argmax(cv_data['AUC_test_avg'])<br />
'''print'''('Best validation AUC score: {:.2f}±{:.2f} on step {}'.format(<br />
best_value,<br />
cv_data['AUC_test_stddev'][best_iter],<br />
best_iter<br />
))<br />
<br />
> '''Best validation AUC score: 0.91±0.00 on step 9'''<br />
<br />
<br />
''Больше примеров<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/python-usages-examples-docpage Примеры ипользования CatBoost]</ref> можно найти на сайте библиотеки''.<br />
<br />
==См. также==<br />
*[[:Дерево_решений_и_случайный_леc|Дерево решений и случайный леc]]<sup>[на 28.01.19 не создан]</sup><br />
*[[:Бустинг,_AdaBoost|Бустинг, AdaBoost]]<br />
<br />
==Примечания==<br />
<references/><br />
<br />
== Источники информации ==<br />
* [https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/| Overview of CatBoost]<br />
* [https://en.wikipedia.org/wiki/Gradient_boosting| Gradient Boosting, WIkipedia]<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=CatBoost&diff=69664CatBoost2019-01-30T19:08:39Z<p>Dariyakovleva: </p>
<hr />
<div>Библиотекой CatBoost {{---}} метод машинного обучения, основанный на градиентном бустинге (англ. ''gradient boosting'').<br />
<br />
<br />
Практически любой современный метод на основе градиентного бустинга работает с числовыми признаками. Если у нас в наборе данных присутствуют не только числовые, но и категориальные признаки (англ. ''categorical features''), то необходимо переводить категориальные признаки в числовые. Это приводит к искажению их сути и потенциальному снижению точности работы модели.<br />
Именно поэтому было важно разработать алгоритм, который умеет работать не только с числовыми признаками, но и с категориальными напрямую, закономерности между которыми этот алгоритм будет выявлять самостоятельно, без ручной «помощи».<br />
CatBoost {{---}} библиотека для градиентного бустинга, главным преимуществом которой является то, что она одинаково хорошо работает «из коробки» как с числовыми признаками, так и с категориальными. <br />
<br />
Документацию по CatBoost можно найти на сайте<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/ Документация CatBoost]</ref>.<br />
<br />
----<br />
== Общий принцип работы ==<br />
<br />
=== Дерево решений ===<br />
<br />
<br />
Алгоритм работы следующий: для каждого документа имеется набор значений признаков, имеется дерево, в вершинах дерева {{---}} условия. Если условие выполнено, осуществляется переход в правого ребенка вершины, иначе в левого. Нужно пройти до листа по дереву в соответствии со значениями признаков для документа. На выходе каждому документу соответствует значение листа. Это и есть ответ.<br />
<br />
=== Бустинг ===<br />
<br />
<br />
Идея бустинг-подхода заключается в комбинации слабых (с невысокой обобщающей способностью) функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Результирующая функция представляет собой линейную комбинацию базовых, слабых моделей. Более подробно можно посмотреть в статье про градиентный бустинг<ref>[https://en.wikipedia.org/wiki/Gradient_boosting |Gradient Boosting, Wikipedia]</ref>.<br />
<br />
Далее будет рассматриваться бустинг деревьев решений. Будем строить несколько деревьев, чтобы добавление новых деревьев уменьшало ошибку. Итого при достаточно большом количестве деревьев мы сможем сильно уменьшить ошибку, однако не стоит забывать, что чем больше деревьев, тем дольше обучается модель и в какой-то момент прирост качества становится незначительным.<br />
<br />
=== Градиентный бустинг ===<br />
<br />
* В основе CatBoost лежит градиентный бустинг.<br />
<br />
* Градиент функции ошибки {{---}} все производные по всем значениям функции<br />
Градиентный бустинг {{---}} метод машинного обучения, который создает решающую модель прогнозирования в виде ансамбля слабых моделей прогнозирования, обычно деревьев решений. Он строит модель поэтапно, позволяя оптимизировать произвольную дифференцируемую функцию потерь.<br />
<br />
== Особенности CatBoost ==<br />
<br />
=== Режимы работы ===<br />
<br />
* Регрессия (англ. ''regression''); <br />
* Классификация (англ. ''classification'');<br />
Функция потерь (англ. ''loss function'') {{---}} максимизируем вероятность того, что все объекты в обучающей выборке классифицированы правильно, вероятность - это сигмоида над значением формулы.<br />
Функция ''predict_proba'' {{---}} на выходе получаем готовые вероятности. Нужно отметить, что складывать их уже нельзя.<br />
Функция ''predict'' {{---}} выдает необработанный результат. Такой результат можно складывать, например, с результатами других моделей.<br />
* Мультиклассификация (англ. ''multiclass classification'');<br />
* Ранжирование (англ. ''ranking'').<br />
Объекты с попарной классификацией (??)<br />
<br />
=== Метрики ===<br />
<br />
Поддерживает множество [[Оценка_качества_в_задачах_классификации_и_регрессии|метрик]]<sup>[на 28.01.19 не создан]</sup> (англ. ''metrics''), таких как:<br />
* Регрессия: ''MAE, MAPE, RMSE, SMAPE'' etc.;<br />
* Классификация: ''Logloss , Precision, Recall, F1, CrossEntropy, BalancedAccuracy'' etc.;<br />
* Мультиклассификация: ''MultiClass, MultiClassOneVsAll, HammingLoss, F1'' etc.;<br />
* Ранжирование: ''NDCG, PrecisionAt, RecallAt, PFound, PairLogit'' etc.<br />
<br />
== Обучение ==<br />
=== Шаги обучения ===<br />
<br />
* Строим дерево;<br />
* Считаем значение в листьях.<br />
<br />
=== Построение дерева ===<br />
<br />
Процесс построения происходит жадно. <br />
<br />
* Выбираем первую вершину;<br />
* Выбираем лучшее дерево с одной вершиной; <br />
* Считаем метрику и по ней выбираем лучшее дерево.<br />
<br />
Дерево строится по слоям. Гарантировано на каждом слое один и тот же сплит (условие по которому мы делим).<br />
<br />
=== Вычисление значений в листьях === <br />
Во время вычисления значений в листьях можем позволить себе сделать больше операций, так как у нас уже зафиксирована структура дерева и значения в листьях будут вычислены единожды. Поэтому можем себе позволить даже сделать несколько шагов по градиенту или применить метод Ньютона.<br />
<br />
=== Как выбрать лучшее дерево? ===<br />
<br />
Смотрим, на сколько меняется функция ошибки, выбираем такое дерево, чтобы оно как можно лучше приближало вектор градиентов.<br />
<br />
=== Как работает градиентный бустинг? ===<br />
<br />
Отметим, что существует идеальный шаг по градиенту, однако листьев в дереве меньше, чем документов в датасете.<br />
Поэтому мы можем пытаться приближать тот самый идеальный шаг.<br />
Чтобы найти лучший сплит, проверяем похожесть после одного шага алгоритма по градиенту.<br />
<br />
=== Рандомизация ===<br />
<br />
Есть рандомизация метрики, по которой выбирается лучшее дерево. <br />
''Score += random_strength * Rand (0, lenofgrad * q)'' <br />
<br />
''q'' {{---}} множитель, уменьшающийся при увеличении итерации. <br />
Таким образом, рандом уменьшается ближе к концу.<br />
<br />
----<br />
<br />
== Работа с датасетом ==<br />
<br />
=== Режимов выборки данных ===<br />
<br />
CatBoost поддерживает несколько режимов выборки данных<br />
<br />
* Бутстрап (англ. ''bootstrap'') Бернулли {{---}} выбираем документ с вероятностью ''p''. Регулируется параметром ''sample_rate'';<br />
* Байесовский бутстрап {{---}} байесовское распределение. Регулируется параметром ''bagging_temp''.<br />
<br />
Отметим, что бутстрап используется только для выбора структуры дерева, для подсчета значения в листьях используем всю выборку. Это сделано, так как выбор структуры дерева происходит долго, нужно несколько раз пересчитывать значения, поэтому использовать всю выборку слишком дорого. Однако значения в листьях с уже готовой структурой дерева считаются один раз, и для большей точности можно позволить использовать весь датасет.<br />
<br />
=== Бинаризация признаков ===<br />
<br />
Пробовать все {{---}} долго. Поэтому выбираем сетку заранее и ходим по ней.<br />
<br />
Есть несколько способов выбора:<br />
<br />
* Uniform. Равномерно разбиваем отрезок от минимума значения для данного признака до максимума;<br />
* Медианная сетка. Задаем количество разбиений над множеством значений, далее идем по объектам в порядке сортировки и разбиваем на группы по k объектов, где k {{---}} количество объектов в одном слоте разбиения;<br />
* UniformAndQuantiles. Комбинация 1 и 2 пунктов;<br />
* MaxSumLog {{---}} в основе лежит динамика, работает долго;<br />
* GreedyLogSum {{---}} аналог MaxSumLog, используется жадный алгоритм, поэтому работает не точно, однако быстрее чем MaxSumLog.<br />
<br />
=== Работа с категориальными признаками ===<br />
<br />
* LabelEncoding {{---}} на реальных примерах точность работы низкая, так как появляется отношения порядка между объектами;<br />
* One-hot encoding {{---}} дает неплохую точность, если различных значений признаков не много. Иначе один признак размножится на множество признаков и будет влиять на модель заведомо сильнее остальных признаков.<br />
<br />
Лучше не делать препроцессинг самим из-за проблем, описанных выше. В CatBoost можно задать параметр cat_features, передав туда индексы категориальных признаков. Также можно отрегулировать параметр ''one_hot_max_size'' {{---}} максимальное количество различных значений у категориального признака, чтобы он мог в последствии быть подвержен one-hot encoding.<br />
<br />
== Подбор параметров ==<br />
<br />
Ниже описаны гиперпараметры (англ. ''hyperparameters''), на которые стоит обратить внимание при использовании библиотеки.<br />
<br />
* cat_features;<br />
* Overfitting detector;<br />
* Число итераций и learning rate;<br />
* L2_reg;<br />
* Random_srength;<br />
* Bagging_temp;<br />
* Глубина дерева (стоит попробовать 10 и 6).<br />
<br />
== Полезная функциональность ==<br />
<br />
* Snapshots;<br />
* Overfitting detector;<br />
* CV;<br />
* eval_metrics.<br />
<br />
== Бенчмарки ==<br />
<br />
Сравнение библиотеки CatBoost с открытыми аналогами XGBoost, LightGBM и H20 на наборе публичных датасетов<ref>[https://catboost.yandex/#benchmark| Benchmarks]</ref>.<br />
<br />
== Пример использования ==<br />
* Делим данные на тренировочное и тестовое множество<br />
'''from''' sklearn.model_selection '''import''' train_test_split<br />
<br />
X_train, X_validation, y_train, y_validation = train_test_split(X, y, '''train_size'''=0.5, '''random_state'''=1234)<br />
'''print'''(X_train.shape, X_validation.shape)<br />
<br />
* Создаем классификатор<br />
'''from''' catboost '''import''' CatBoostClassifier<br />
<br />
best_model = CatBoostClassifier(<br />
'''bagging_temperature'''=1,<br />
'''random_strength'''=1,<br />
'''thread_count'''=3,<br />
'''iterations'''=500,<br />
'''l2_leaf_reg''' = 4.0, <br />
'''learning_rate''' = 0.07521709965938336,<br />
'''save_snapshot'''=True,<br />
'''snapshot_file'''='snapshot_best.bkp',<br />
'''random_seed'''=63,<br />
'''od_type'''='Iter',<br />
'''od_wait'''=20,<br />
'''custom_loss'''=['AUC', 'Accuracy'],<br />
'''use_best_model'''=True<br />
)<br />
<br />
* Обучаемся<br />
<br />
best_model.fit(<br />
X_train, y_train,<br />
'''cat_features'''=cat_features,<br />
'''eval_set'''=(X_validation, y_validation),<br />
'''logging_level'''='Silent',<br />
'''plot'''=True<br />
)<br />
<br />
* Вывод числа деревьев в модели<br />
<br />
'''print'''('Resulting tree count:', best_model.tree_count_)<br />
<br />
> '''Resulting tree count: 217'''<br />
<br />
* Используем скользящий контроль (англ. cross validation)<br />
'''from''' catboost '''import''' cv<br />
<br />
params = best_model.get_params()<br />
params['iterations'] = 10<br />
params['custom_loss'] = 'AUC'<br />
del params['use_best_model']<br />
pool1 = Pool(X, '''label'''=y, '''cat_features'''=cat_features)<br />
<br />
cv_data = cv(<br />
'''params''' = params,<br />
'''pool''' = pool1,<br />
'''fold_count'''=2,<br />
'''inverted'''=False,<br />
'''shuffle'''=True,<br />
'''stratified'''=False,<br />
'''partition_random_seed'''=0<br />
)<br />
<br />
* Выводим результат<br />
best_value = np.max(cv_data['AUC_test_avg'])<br />
best_iter = np.argmax(cv_data['AUC_test_avg'])<br />
'''print'''('Best validation AUC score: {:.2f}±{:.2f} on step {}'.format(<br />
best_value,<br />
cv_data['AUC_test_stddev'][best_iter],<br />
best_iter<br />
))<br />
<br />
> '''Best validation AUC score: 0.91±0.00 on step 9'''<br />
<br />
<br />
''Больше примеров<ref>[https://tech.yandex.com/catboost/doc/dg/concepts/python-usages-examples-docpage Примеры ипользования CatBoost]</ref> можно найти на сайте библиотеки''.<br />
<br />
==См. также==<br />
*[[:Дерево_решений_и_случайный_леc|Дерево решений и случайный леc]]<sup>[на 28.01.19 не создан]</sup><br />
*[[:Бустинг,_AdaBoost|Бустинг, AdaBoost]]<br />
<br />
==Примечания==<br />
<references/><br />
<br />
== Источники информации ==<br />
* [https://tech.yandex.com/catboost/doc/dg/concepts/about-docpage/| Overview of CatBoost]<br />
* [https://en.wikipedia.org/wiki/Gradient_boosting| Gradient Boosting, WIkipedia]<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%92%D1%8B%D0%B1%D1%80%D0%BE%D1%81&diff=69654Выброс2019-01-30T00:03:53Z<p>Dariyakovleva: </p>
<hr />
<div>[[Файл:Outlier_boxplot.png|upright=1.0|thumb|Рис 1.График boxplot населения регионов России в 1990 году, где можно заметить 5 выбросов]]<br />
'''Выброс''' (англ. ''outlier'') {{---}} небольшая доля объектов во входных данных, которая сильно выделяется из общей выборки. Многие алгоритмы машинного обучения чувствительны к разбросу и распределению значений признаков обрабатываемых объектов. Соответственно, выбросы во входных данных могут исказить и ввести в заблуждение процесс обучения алгоритмов машинного обучения, что приводит к увеличению времени обучения, снижению точности моделей и, в конечном итоге, к снижению результатов. Даже до подготовки предсказательных моделей на основе обучающих данных выбросы могут приводить к ошибочным представлениям и в дальнейшем к ошибочной интерпретации собранных данных.<br />
===Виды выбросов===<br />
Выбросы могут быть двух видов: одномерные и многомерные. Одномерные выбросы можно найти при рассмотрении распределения значений объектов в одномерном пространстве. Многомерные выбросы можно найти в <tex>n</tex>-мерном пространстве (из <tex>n</tex> объектов). Рассмотрение распределений в <tex>n</tex>-мерных пространствах может быть очень сложным для человеческого мозга, поэтому необходимо обучить модель, чтобы сделать это.<br />
<br />
Выбросы также могут отличаться в зависимости от окружающей среды: точечные выбросы, контекстуальные выбросы или коллективные выбросы. Точечные выбросы {{---}} <br />
единичные точки данных, расположенные далеко от остальной части распределения. Контекстные выбросы могут представлять собой шум в данных, например, знаки препинания при выполнении анализа текста или сигнал фонового шума при распознавании речи. Коллективные выбросы могут быть подмножествами новшеств в данных, таких как сигнал, который может указывать на открытие новых явлений.<br />
<br />
===Причины возникновения выбросов===<br />
* Сбой работы оборудования;<br />
* Человеческий фактор;<br />
* Случайность;<br />
* Уникальные явления;<br />
* и др.<br />
==Примеры==<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:Outlier_norm.png|200px|thumb|Рис 2. Хорошо обученная модель с выбросами]]<br />
|[[Файл:Outlier_bad.png|200px|thumb|Рис 3. Переобученная модель на выбросах]]<br />
|}<br />
Рис 2 показывает хорошо обученную модель, в которой присутствуют два выброса. Как видно из рисунка данная модель показала себя устойчивой к выбросам, либо же вовремя прекратила своё обучение. Обратная ситуация обстоит с Рис 3, где модель сильно переобучилась из-за присутствующих в ней выбросов. <br />
==Методы обнаружения и борьбы с выбросами== <br />
===Методы обнаружения выбросов===<br />
[[Файл:Outlier_normal_distribution.png|upright=1.0|thumb|[http://work.thaslwanter.at/Stats/html/statsDistributions.html Рис 4. Так как t-распределение имеет более длинный хвост, нежели у нормального распределения, поэтому t-распределение менее чувствительно к выбросам.]]]<br />
# Экстремальный анализ данных(англ. ''extreme value analysis''). При таком анализе не применяются какие-либо специальные статистические методы. Обычно этот метод применим для одномерного случая. Алгоритм использования таков:<br />
#* Визуализировать данные, используя диаграммы и гистограммы для нахождения экстремальных значений; <br />
#* Задействовать распределение, например Гауссовское, и найти значения, чье стандартное отклонение отличается в 2-3 раза от математического ожидания или в полтора раза от первой либо третьей квартилей; <br />
#* Отфильтровать предполагаемые выбросы из обучающей выборки и оценить работу модели;<br />
# Аппроксимирующий метод (англ. ''proximity method''). Чуть более сложный метод, заключающийся в применении кластеризующих методов;<br />
#* Использовать метод кластеризации для определения кластеров в данных;<br />
#* Идентифицировать и отметить центроиды каждого кластера;<br />
#* Соотнести кластеры с экземплярами данных, находящимися на фиксированном расстоянии или на процентном удалении от центроида соответствующего кластера;<br />
#* Отфильтровать предполагаемые выбросы из обучающей выборки и оценить работу модели;<br />
# Проецирующие методы (англ. ''projections methods''). Эти методы довольно быстро и просто определяют выбросы в выборке; <br />
#* Использовать один из проецирующих методов, например, метод главных компонент (англ. ''principal component analysis'', ''PCA''<ref>[https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D1%8B%D1%85_%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82 Метод главных компонент]</ref>) или самоорганизующиеся карты Кохонена(англ. ''self-organizing map'', ''SOM''<ref>[https://habr.com/post/338868/ Самоорганизующиеся карты Кохонена]</ref>) или проекцию Саммона(англ. ''Sammon mapping'', ''Sammon projection''<ref>[https://en.wikipedia.org/wiki/Sammon_mapping Проекция Саммона]</ref>), для суммирования обучающих данных в двух измерениях;<br />
#* Визуализировать отображение;<br />
#* Использовать критерий близости от проецируемых значений или от вектора таблицы кодирования (англ. ''codebook vector'') для идентифицирования выбросов;<br />
#* Отфильтровать предполагаемые выбросы из обучающей выборки и оценить работу модели.<br />
<br />
===Локально взвешенное сглаживание===<br />
Локально взвешенное сглаживание (англ. ''LOcally WEighted Scatter plot Smoothing'', ''LOWESS'')<ref>[http://www.aliquote.org/cours/2012_biomed/biblio/Cleveland1979.pdf Локально взвешенное сглаживание]</ref>. Данная методика была предложена Кливлендом (Cleveland) в 1979 году для моделирования и сглаживания двумерных данных <math>X^m={(x_i, y_i)}_{i=1}^m</math>. Эта техника предоставляет общий и гибкий подход для приближения двумерных данных. Локально-линейная модель может быть записана в виде: <math>y_t=\alpha_t+\beta_t x_t + \varepsilon_t</math>. Эта модель может быть расширена на случай локально-квадратичной зависимости и на модель с бо‘льшим числом независимых переменных. Параметры <math>\alpha_t</math> и <math>\beta_t</math> локально линейной модели оцениваются с помощью локально взвешенной регрессии, которая присваивает объекту тем больший вес, чем более близок он к объекту t. Степень сглаживания определяется параметром сглаживания <math>f</math>, который выбирает пользователь. Параметр <math>f</math> указывает какая доля (англ. ''fraction'') данных используется в процедуре. Если <math>f = 0.5</math>, то только половина данных используется для оценки и влияет на результат, и тогда мы получим умеренное сглаживание. С другой стороны, если <math>f = 0.8</math>, то используются восемьдесят процентов данных, и сглаживание намного сильнее. Во всех случаях веса данных тем больше, чем они ближе к объекту <math>t</math>.<br />
====Постановка задачи====<br />
Пусть задано пространство объектов $X$ и множество возможных ответов <math>Y = \mathbb{R}</math>. Существует неизвестная зависимость <math>y^*\colon X \to Y</math>, значения которой известны только на объектах обучающией выборки <math>X^l = (x_i\ ,\ y_i)^l_{i=1},\ y_i = y^*(x_i)</math>. Требуется построить алгоритм <math>a\colon X\to Y</math>, аппроксимирующий неизвестную зависимость <math>y^*</math>. Предполагается, что на множестве $X$ задана метрика <math>\rho(x,x')</math>.<br />
<br />
Также стоит определить следующее. Для вычисления <math>a(x) = \alpha</math> для <math>\forall x \in X</math> воспользуемся методом наименьших квадратов:<br />
<math>Q(\alpha;X^l) = \sum_{i=1}^l \omega_i(x)(\alpha-y_i)^2 \rightarrow \underset{\alpha \in \mathbb{R}}{min}</math>, где <math>\omega_i</math> {{---}} это вес $i$-ого объекта. <br />
<br />
Веса <math>\omega_i</math> разумно задать так, чтобы они убывали по мере увеличения расстояния <math>\rho(x,x_i)</math>. Для этого можно ввести невозрастающую, гладкую, ограниченную функцию <math>K:[0, \infty) \rightarrow [0, \infty)</math>, называемую [[Ядра|ядром]]<sup>[на 28.01.19 не создан]</sup>, и представить <math>\omega_i</math> в следующем виде:<br />
<br />
<br />
<math>\omega_i(x) = K\left(\frac{\rho(x,x_i)}{h} \right )</math>, где $h$ {{---}} ширина окна.<br />
<br />
<br />
Приравняв равной нулю производную <math>\frac{\partial Q}{\partial \alpha} = 0</math> и выразив <math>\alpha</math>, получаем ''формулу Надарая-Ватсона''<ref>[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D1%86%D0%B5%D0%BD%D0%BA%D0%B0_%D0%9D%D0%B0%D0%B4%D0%B0%D1%80%D0%B0%D1%8F-%D0%92%D0%B0%D1%82%D1%81%D0%BE%D0%BD%D0%B0 Формула Надарая-Ватсона]</ref> :<br />
<math>a_h(x;X^l) = \frac{\sum_{i=1}^{l} y_i\omega_i(x)}{\sum_{i=1}^{l} \omega_i(x)} = \frac{\sum_{i=1}^{l} y_iK\left(\frac{\rho(x,x_i)}{h} \right )}{\sum_{i=1}^{l} K\left(\frac{\rho(x,x_i)}{h} \right )}</math>.<br />
<br />
====Проблема выбросов в этой задаче====<br />
Большие случайные ошибки в значениях <math>y_i</math> сильно искажают оценку Надарая-Ватсона.<br />
<br />
====Идея====<br />
Чем больше величина невязки <math>\varepsilon_i = \left | a_h\left (x_i;X^\ell\backslash\left \{x_i\right \} \right )-y_i\right |</math>, тем меньше должен быть вес i-го объекта <math>\omega_i(x)</math>.<br />
====Эвристика====<br />
Домножить веса <math>\omega_i(x)</math> на коэффиценты <math>\gamma_i = \widetilde{K}\left ( \varepsilon_i \right )</math>, где <math>\widetilde{K}\left ( \varepsilon \right )</math> — ещё одно ядро, вообще говоря, отличное от <math>K\left ( \rho \right )</math>.<br />
<br />
====Псевдокод====<br />
INPUT: <math>X^\ell</math> - training sample;<br />
OUTPUT: coefficents <math>\gamma_i, i = 1,...,\ell</math>;<br />
________________________________________________________<br />
1: initialization: <math>\gamma_i := 1, i = 1,...,\ell</math>; <span style="color:green">//инициализация коэффициентов</span><br />
2: do<br />
3: for each object <math>i = 1,...,\ell</math>;<br />
4: calculate cross-validation estimates: <span style="color:green">//вычислить оценки скользящего контроля</span><br />
<math>a_i := a_h(x_i;X^\ell\setminus{x_i}) = \frac{\sum\limits^{\ell}_{j=1,j\ne i} {y_j\gamma_j K \left ( \tfrac{\rho\left (x_i,x_j \right )}{h\left (x_i \right)} \right )}}{\sum\limits^{\ell}_{j=1,j\ne i}{\gamma_j K\left(\tfrac{\rho\left (x_i,x_j \right )}{h\left (x_i\right )}\right )} }</math><br />
5: for each object <math>i = 1,...,\ell</math>;<br />
6: <math>\gamma_i := \widetilde{K}\left (\left | a_i-y_i \right | \right );</math><br />
7: while coefficents <math>\gamma_i</math> not stabilized; <span style="color:green">//пока коэффициенты не стабилизируются</span><br />
<br />
====Пример на языке R==== <br />
В этом примере мы попытаемся локально регрессировать и сгладить среднюю продолжительность безработицы на основе набора экономических данных из пакета $ggplot2$ языка $R$. Мы рассматриваем только первые 80 строк для этого анализа, чтобы легче было наблюдать степень сглаживания на приведенных ниже графиках.<br><br />
data(economics, package="ggplot2") <span style="color:green"># загрузка данных</span><br />
economics$index <- 1:nrow(economics) <span style="color:green"># создание индексной переменной</span><br />
economics <- economics[1:80, ] <span style="color:green"># усечение до 80 строк для более наглядного демонстрирования</span><br />
loessMod10 <- loess(uempmed ~ index, data=economics, span=0.10) <span style="color:green"># 10% параметр сглаживания span</span><br />
loessMod25 <- loess(uempmed ~ index, data=economics, span=0.25) <span style="color:green"># 25% параметр сглаживания span</span><br />
loessMod50 <- loess(uempmed ~ index, data=economics, span=0.50) <span style="color:green"># 50% параметр сглаживания span</span><br />
<br />
<span style="color:green"># получить сглаженный результат</span><br />
smoothed10 <- predict(loessMod10) <br />
smoothed25 <- predict(loessMod25) <br />
smoothed50 <- predict(loessMod50)<br />
<br />
<span style="color:green"># Нарисовать</span><br />
plot(economics''$''uempmed, x=economics''$''date, type="l", main="Локально взвешенное сглаживание", xlab="Дата", ylab="Длительность безработицы")<br />
lines(smoothed10, x=economics''$''date, col="red")<br />
lines(smoothed25, x=economics''$''date, col="green")<br />
lines(smoothed50, x=economics''$''date, col="blue")<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:LOWESS.png|400px|thumb|Рис 5. На приведенном графике показано, что чем больше параметр сглаживания span, тем более сглаженной выглядит восстановленная регрессия]]<br />
|}<br />
<br />
===Другие алгоритмы борьбы с выбросами===<br />
В статистике методы, устойчивые к нарушениям модельных предположений о данных, называются ''робастными''. Метод локально взвешенного сглаживания относится к ''робастным'' методам, так как он устойчив к наличию небольшого количества выбросов. <br />
* [[Дерево решений и случайный лес|Дерево принятия решения]] (англ. ''decision tree''<ref>[https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B9 Дерево принятия решения]</ref>). Это дерево, как и уже описанный алгоритм локально взвешенного сглаживания, относится к ''робастным'' методам;<br />
* [[Вариации регрессии|Робастная регрессия]] (англ. ''robust regression''<ref>[https://en.wikipedia.org/wiki/Robust_regression Робастная регрессия]</ref>). В отличии от регрессии, использующей, например, метод наименьших квадратов, в этом алгоритме не строится идеализированное предположение, что вектор ошибок <math>\varepsilon</math> распределен согласно нормальному закону. Однако на практике зачастую имеют место отклонения от этого предположения. Тогда можно применить метод наименьших модулей (англ. ''Least Absolute Deviation, LAD ''<ref>[https://en.wikipedia.org/wiki/Least_absolute_deviations Метод наименьших модулей]</ref>) в случае, если распределение ошибок измерений подчиняется распределению Лапласа (англ. Laplace distribution <ref>[https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%9B%D0%B0%D0%BF%D0%BB%D0%B0%D1%81%D0%B0 Распределение Лапласа]</ref>).<br />
<br />
==См.также==<br />
* [[Общие понятия]]<br />
* [[Переобучение]]<br />
* [[Дерево решений и случайный лес]]<br />
<br />
==Примечания==<br />
<references/><br />
==Источники информации==<br />
# https://machinelearningmastery.com/how-to-identify-outliers-in-your-data/<br />
# https://ru.coursera.org/lecture/vvedenie-mashinnoe-obuchenie/obnaruzhieniie-vybrosov-t9PG4<br />
[[Категория: Машинное обучение]]<br />
[[Категория: Статистика]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D1%80%D0%BE%D1%81%D1%81-%D0%B2%D0%B0%D0%BB%D0%B8%D0%B4%D0%B0%D1%86%D0%B8%D1%8F&diff=69653Кросс-валидация2019-01-29T23:53:28Z<p>Dariyakovleva: </p>
<hr />
<div>'''Кросс-валидация''' или '''скользящий контроль''' {{---}} процедура эмпирического оценивания обобщающей способности алгоритмов. <br />
С помощью кросс-валидации эмулируется наличие тестовой выборки, которая не участвует в обучении, но для которой известны правильные ответы. <br />
<br />
=== Определения и обозначения === <br />
Пусть <tex> X </tex> {{---}} множество [[Общие понятия | признаков]], описывающих объекты, а <tex> Y </tex> {{---}} конечное множество меток.<br />
<br />
<tex>T^l = {(x_i, y_i)}_{i=1}^{l}, x_i \in X, y_i \in Y</tex> {{---}} обучающая выборка,<br />
<br />
<tex>Q</tex> {{---}} мера качества,<br />
<br />
<tex>A</tex> {{---}} [[Модель алгоритма и ее выбор | модель]],<br />
<br />
<tex>\mu: (X \times Y)^l \to A, </tex> {{---}} алгоритм обучения.<br />
<br />
== Разновидности кросс-валидации ==<br />
<br />
=== Валидация на отложенных данных (Hold-Out Validation) ===<br />
<br />
Обучающая выборка один раз случайным образом разбивается на две части <tex> T^l = T^t \cup T^{l-t} </tex><br />
<br />
[[Файл:Hold-out.png|500px]]<br />
<br />
<br />
После чего решается задача оптимизации: <br />
<br />
<tex>HO(\mu, T^t, T^{l-t}) = Q(\mu(T^t), T^{l-t}) \to min </tex>,<br />
<br />
Метод Hold-out применяется в случаях больших датасетов, т.к. требует меньше вычислительных мощностей по сравнению с другими методами кросс-валидации. <br />
Недостатком метода является то, что оценка существенно зависит от разбиения, тогда как желательно, чтобы она характеризовала только алгоритм обучения.<br />
<br />
=== Полная кросс-валидация (Complete cross-validation) ===<br />
# Выбирается значение <tex>t</tex>;<br />
# Выборка разбивается всеми возможными способами на две части <tex> T^l = T^t \cup T^{l-t} </tex>.<br />
<br />
[[Файл:CompleteCrossValidation.png|500px]]<br />
<br />
<tex>CVV_t = \frac{1}{C_l^{l-t}} <br />
\displaystyle\sum_{T^l = T^t \cup T^{l-t}} Q(\mu(T^t), T^{l-t}) \to min </tex>,<br />
<br />
Здесь число разбиений <tex>C_l^{l-t}</tex> становится слишком большим даже при сравнительно малых значениях t, что затрудняет практическое применение данного метода.<br />
<br />
=== k-fold кросс-валидация ===<br />
<br />
# Обучающая выборка разбивается на <tex> k </tex> непересекающихся одинаковых по объему частей;<br />
# Производится <tex> k </tex> итераций. На каждой итерации происходит следующее:<br />
## Модель обучается на <tex> k - 1 </tex> части обучающей выборки;<br />
## Модель тестируется на части обучающей выборки, которая не участвовала в обучении.<br />
Каждая из <tex>k</tex> частей единожды используется для тестирования. <br />
Как правило, <tex>k = 10</tex> (5 в случае малого размера выборки).<br />
<br />
[[Файл:K-fold-validation.png|500px]]<br />
<br />
<tex>T^l = F_1 \cup \dots \cup F_k, |F_i| \approx \frac{l}{k}, <br />
\\ CV_k = \frac{1}{k} \sum_{i=1}^{k} Q(\mu(T^l \setminus F_i),F_i) \to min </tex>.<br />
<br />
=== t×k-fold кросс-валидация === <br />
# Процедура выполняется <tex>t</tex> раз: <br />
## Обучающая выборка случайным образом разбивается на <tex>k</tex> непересекающихся одинаковых по объему частей;<br />
## Производится <tex> k </tex> итераций. На каждой итерации происходит следующее:<br />
### Модель обучается на <tex> k - 1 </tex> части обучающей выборки;<br />
### Модель тестируется на части обучающей выборки, которая не участвовала в обучении.<br />
<br />
<br />
<tex>T^l = F_{(1,1)} \cup \dots \cup F_{(k,1)} = \dots = F_{(1,t)} \cup \dots \cup F_{(k,t)}, |F_{(i,j)}| \approx \frac{l}{k} </tex>, <br />
<br />
<tex> CV_{t \times k} = \frac{1}{tk} \sum_{j=1}^t \sum_{i=1}^{k} Q(\mu(T^l \setminus F_{(i,j)}),F_{(i,j)}) \to min </tex>.<br />
<br />
=== Кросс-валидация по отдельным объектам (Leave-One-Out) === <br />
Выборка разбивается на <tex>l-1</tex> и 1 объект <tex>l</tex> раз.<br />
<br />
[[Файл:LeaveOneOut.png|500px]]<br />
<br />
<tex>LOO = \frac{1}{l} \sum_{i=1}^{l} Q(\mu(T^l \setminus p_i),p_i) \to min </tex>, где <tex>p_i = (x_i, y_i)</tex>.<br />
<br />
Преимущества LOO в том, что каждый объект ровно один раз участвует в контроле, а длина обучающих подвыборок лишь на единицу меньше длины полной выборки.<br />
<br />
Недостатком LOO является большая ресурсоёмкость, так как обучаться приходится <tex>L</tex> раз. Некоторые методы обучения позволяют достаточно быстро перенастраивать внутренние параметры алгоритма при замене одного обучающего объекта другим. В этих случаях вычисление LOO удаётся заметно ускорить.<br />
<br />
=== Случайные разбиения (Random subsampling) === <br />
Выборка разбивается в случайной пропорции. Процедура повторяется несколько раз.<br />
<br />
[[Файл:CompleteCrossValidation.png|500px]]<br />
<br />
=== Критерий целостности модели (Model consistency criterion) === <br />
Не переобученый алгоритм должен показывать одинаковую эффективность на каждой части.<br />
<br />
[[Файл:ModelConsistencyCriterion.png|500px]]<br />
<br />
<tex> D_1 = (\mu, T^{l-t}) = \frac{1}{l} \sum_{i=1}^l (\mu(T^t)(x_i)-\mu(T^{l-t})(x_i)) </tex>,<br />
<br />
Метод может быть обобщен как аналог <tex> CV_{t \times 2} </tex>.<br />
<br />
== См. также ==<br />
* [[Общие понятия]]<br />
* [[Модель алгоритма и ее выбор]]<br />
* [[Мета-обучение]]<br />
<br />
== Примечания ==<br />
# [https://en.wikipedia.org/wiki/Cross-validation_(statistics) Кросс-валидация]<br />
<br />
== Источники информации ==<br />
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%A1%D0%BA%D0%BE%D0%BB%D1%8C%D0%B7%D1%8F%D1%89%D0%B8%D0%B9_%D0%BA%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D1%8C Скользящий контроль] - статья на MachineLearning.ru<br />
# [https://drive.google.com/open?id=1p9CTAa1_gJpj94RXBEcQ09aVOa-KTlrd Model assessment and selection]<br />
<br />
[[Категория: Машинное обучение]]<br />
<br />
[[Категория: Автоматическое машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%B5%D1%80%D0%B5%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5&diff=69652Переобучение2019-01-29T23:48:59Z<p>Dariyakovleva: </p>
<hr />
<div>'''Переобучение''' (англ. overfitting) {{---}} негативное явление, возникающее, когда алгоритм обучения вырабатывает предсказания, которые слишком близко или точно соответствуют конкретному набору данных и поэтому не подходят для применения алгоритма к дополнительным данным или будущим наблюдениям.<br />
<br />
'''Недообучение''' (англ. underfitting) {{---}} негативное явление, при котором алгоритм обучения не обеспечивает достаточно малой величины средней ошибки на обучающей выборке. Недообучение возникает при использовании недостаточно сложных моделей.<br />
<br />
== Примеры ==<br />
=== На примере [[Линейная регрессия | линейной регрессии]]<sup>[на 28.01.19 не создан]</sup> ===<br />
Представьте задачу [[Линейная регрессия | линейной регрессии]]<sup>[на 28.01.19 не создан]</sup>. Красные точки представляют исходные данные. Синии линии являются графиками полиномов различной степени M, аппроксимирующих исходные данные.<br />
<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:High_bias_reg.png|200px|thumb|Рис 1. Недообучение. M=1]]<br />
|[[Файл:Normal_bias_reg.png|200px|thumb|Рис 2. Норма. M=2]]<br />
|[[Файл:High_variance_reg.png|200px|thumb|Рис 3. Переобучение. M=4]]<br />
|}<br />
<br />
Как видно из Рис. 1, данные не поддаются линейной зависимости при небольшой степени полинома и по этой причине модель, представленная на данном рисунке, не очень хороша.<br />
<br />
На Рис. 2 представленна ситуация, когда выбранная полиномиальная функция подходит для описания исходных данных.<br />
<br />
Рис. 3 иллюстрирует случай, когда высокая степень полинома ведет к тому, что модель слишком заточена на данные обучающего датасета.<br />
<br />
=== На примере [[Логистическая регрессия | логистической регрессии]] ===<br />
Представьте задачу классификации размеченых точек. Красные точки представляют данные класса 1. Голубые круглые точки {{---}} класса 2. Синии линии являются представлением различных моделей, которыми производится классификация данных. <br />
<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:High_bias_cla.png|200px|thumb|Рис 4. Недообучение]]<br />
|[[Файл:Normal_bias_cla.png|200px|thumb|Рис 5. Подходящая модель]]<br />
|[[Файл:High_variance_cla.png|200px|thumb|Рис 6. Переобучение]]<br />
|}<br />
Рис. 4 показывает результат использования слишком простой модели для представленного датасета. Как видно из рисунка, данные плохо классифицируются такой моделью.<br />
<br />
При выявлении недообучения следует выбрать более сложную модель (Рис. 5), которая бы смогла лучше описать представленные данные.<br />
<br />
Выбор слишком сложной модели приводит к ситуации, когда модель максимально точно классифицирует обучающую выборку, но сильно ошибается на новых измерениях. Данная ситуация представлена на Рис. 6.<br />
<br />
== Кривые обучения ==<br />
'''Кривая обучения''' {{---}} графическое представление того, как изменение меры обученности (по вертикальной оси) зависит от определенной единицы измерения опыта (по горизонтальной оси)<ref>[https://en.wikipedia.org/wiki/Learning_curve Learning curve, Wikipedia]</ref>. Например, в примерах ниже представлена зависимость средней ошибки от объема датасета.<br />
<br />
=== Кривые обучения при переобучении ===<br />
При переобучении небольшая средняя ошибка на обучающей выборке не обеспечивает такую же малую ошибку на тестовой выборке. <br />
<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:High_variance_learning_curve.png|border|400px|Кривые обучения при переобучении|thumb|Рис 7. Кривые обучения при переобучении]]<br />
|}<br />
<br />
Рис. 7 демонстрирует зависимость средней ошибки для обучающей и тестовой выборок от объема датасета при переобучении.<br />
<br />
=== Кривые обучения при недообучении ===<br />
При недообучении независимо от объема обучающего датасета как на обучающей выборке, так и на тестовой выборке небольшая средняя ошибка не достигается. <br />
<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:High_bias_learning_curve.png|border|400px|Кривые обучения при переобучении|thumb|Рис 8. Кривые обучения при недообучении]]<br />
|}<br />
<br />
Рис. 8 демонстрирует зависимость средней ошибки для обучающей и тестовой выборок от объема датасета при недообучении.<br />
<br />
== High variance и high bias ==<br />
'''Bias''' {{---}} ошибка неверных предположений в алгоритме обучения. Высокий '''bias''' может привести к недообучению.<br />
<br />
'''Variance''' {{---}} ошибка, вызванная большой чувствительностью к небольшим отклонениям в тренировочном наборе. Высокая дисперсия может привести к переобучению.<br />
<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:High_bias.jpg|border|300px|thumb|right|Рис 9. High variance и high bias]]<br />
|}<br />
<br />
При использовании нейронных сетей '''variance''' увеличивается, а '''bias''' уменьшается с увеличением количества скрытых слоев.<br />
<br />
Для устранения '''high variance''' и '''high bias''' можно использовать смеси и ансамбли. Например, можно составить ансамбль ('''boosting''') из нескольких моделей с высоким '''bias''' и получить модель с небольшим '''bias'''. В другом случае при '''bagging''' соединяются несколько моделей с низким '''bias''', а результирующая модель позволяет уменьшить '''variance'''.<br />
<br />
===Дилемма bias–variance ===<br />
'''Дилемма bias–variance''' {{---}} конфликт в попытке одновременно минимизировать '''bias''' и '''variance''', тогда как уменьшение одного из негативных эффектов, приводит к увеличению другого. Данная дилемма проиллюстрирована на Рис 10.<br />
<br />
{|align="center"<br />
|-valign="top"<br />
|[[Файл:Bias-Variance-Tradeoff.png|border|400px|thumb|right|Рис 10. Дилемма bias–variance]]<br />
|}<br />
<br />
При небольшой сложности модели мы наблюдаем '''high bias'''. При усложнении модели '''bias''' уменьшается, но '''variance''' увеличится, что приводит к проблеме '''high variance'''.<br />
<br />
== Возможные решения ==<br />
=== Возможные решения при переобучении ===<br />
* Увеличение количества данных в наборе;<br />
* Уменьшение количества параметров модели;<br />
* Добавление регуляризации / увеличение коэффициента регуляризации.<br />
<br />
=== Возможные решения при недообучении ===<br />
* Добавление новых параметров модели;<br />
* Использование для описания модели функций с более высокой степенью;<br />
* Уменьшение коэффициента регуляризации.<br />
<br />
== См. также ==<br />
* [[Модель алгоритма и ее выбор]]<br />
* [[Оценка качества в задачах классификации и регрессии]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Оценка качества в задаче кластеризации]]<br />
* [https://www.coursera.org/lecture/machine-learning/the-problem-of-overfitting-ACpTQ The Problem of Overfitting on Coursera, Andrew Ng]<br />
<br />
== Примечания ==<br />
* [http://blog.lokad.com/journal/2009/4/22/overfitting-when-accuracy-measure-goes-wrong.html Overfitting: when accuracy measure goes wrong]<br />
* [http://www3.cs.stonybrook.edu/~skiena/jaialai/excerpts/node16.html The Problem of Overfitting Data]<br />
* [https://elitedatascience.com/overfitting-in-machine-learning Overfitting in Machine Learning]<br />
<br />
== Источники информации ==<br />
# [https://en.wikipedia.org/wiki/Overfitting Overfitting] - статься на Википедии<br />
# [http://www.machinelearning.ru/wiki/index.php?title=Переобучение Переобучение] - вводная статься на MachineLearning.ru<br />
# [https://www.coursera.org/lecture/machine-learning/the-problem-of-overfitting-ACpTQ The Problem of Overfitting] - курс Andrew Ng<br />
# ''Hastie, T., Tibshirani, R., Friedman, J. '' [http://www-stat.stanford.edu/~tibs/ElemStatLearn The Elements of Statistical Learning, 2nd edition.] — Springer, 2009. — 533 p.<br />
# ''Vapnik V.N. '' [http://lib.mexmat.ru/books/9220 Statistical learning theory.] — N.Y.: John Wiley & Sons, Inc., 1998. <br />
# ''Воронцов, К. В. '' [http://www.machinelearning.ru/wiki/images/b/b6/Voron10doct.pdf Комбинаторная теория надёжности обучения по прецедентам]: Дис. док. физ.-мат. наук: 05-13-17. — Вычислительный центр РАН, 2010. — 271 с.</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%B0-%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5&diff=69651Мета-обучение2019-01-29T23:40:51Z<p>Dariyakovleva: </p>
<hr />
<div><b>Мета-обучение</b> {{---}} подход, позволяющий определять оптимальный алгоритм (иногда вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свести задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-признаками. Мета-признак описывает свойство задачи, например, разрежен ли датасет или нет, число категориальных или численных признаков объектов в датасете, число возможных меток, размер датасета и многое другое.<br />
<br />
От хорошей модели ожидается хорошая адаптируемость или генерализуемость новых задач и окружений, с которыми модель не сталкивалась во время обучения.<br />
<br />
Такими задачами являются:<br />
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек смог определить, есть ли на новой картинке кошка;<br />
* Игровой бот, способный быстро обучиться новой игре;<br />
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности.<br />
<br />
Ограничения {{---}} No free lunch teorem.<ref>[https://www.researchgate.net/publication/221997149_No_Free_Lunch_Theorems_for_Search Wolpert and Macready, 1996]</ref><ref>[https://www.researchgate.net/publication/228671734_Toward_a_justification_of_meta-learning_Is_the_no_free_lunch_theorem_a_show-stopper Giraud-Carrier and Provost, 2005]</ref><br />
<br />
<h2>Обзор</h2><br />
<br />
Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,<br />
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.<br />
Оптимальные параметры модели:<br />
<br />
\begin{aligned}<br />
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})].<br />
\end{aligned}<br />
<br />
Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.<br />
<br />
Few-shot классификатор {{---}} конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,<br />
train set $S$ и test set $B$. Часто принимается k-shot N-class задача {{---}} train set содержит $k$ размеченных примеров для каждого из $N$ классов.<br />
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$, каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$<br />
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:<br />
<br />
\begin{aligned}<br />
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})], &\\<br />
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{B\subset \mathcal{D}}[\sum_{(\mathbf{x}, y)\in B}P_\theta(y \vert \mathbf{x})], & \scriptstyle{\text{; trained with mini-batches.}}<br />
\end{aligned}<br />
<br />
Цель в few-shot классификации {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения сделаем следующее:<br />
# возьмем подмножество меток, $L\subset\mathcal{L}$;<br />
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:<br />
<br />
\begin{aligned}<br />
L, y \in L, \forall (x, y) \in S^L, B^L,<br />
\end{aligned}<br />
<br />
# Множество $S^L$ подается на вход модели;<br />
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же как это делается в обучении с учителем.<br />
<br />
Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобы она могла обобщиться до других датасетов.<br />
Красным выделен дифф между обучением с учителем и мета-обучением.<br />
<br />
\begin{aligned}<br />
\theta = \arg\max_\theta \color{red}{E_{L\subset\mathcal{L}}[} E_{\color{red}{S^L \subset\mathcal{D}, }B^L \subset\mathcal{D}} [\sum_{(x, y)\in B^L} P_\theta(x, y\color{red}{, S^L})] \color{red}{]},<br />
\end{aligned}<br />
<br />
Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.<br />
<br />
<h2>Основанные на оптимизации</h2><br />
<br />
Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.<br />
<br />
<h3>LSTM-meta-learner</h3><br />
Оптимизационный алгоритм может быть явно смоделирован. Ravi & Larochelle (2017) это сделали и назвали его "meta-learner". Цель meta-learner'а {{---}} эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.<br />
<br />
Пусть модель ученика будет $M_θ$, параметризованной $θ$, meta-learner $R_Θ$ с параметром $θ$ и функция потерь $\mathcal{L}$.<br />
<br />
Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):<br />
<br />
\begin{aligned}<br />
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t,<br />
\end{aligned}<br />
<br />
Обновление памяти ячейки LSTM выглядит так:<br />
<br />
\begin{aligned}<br />
c_t = f_t \odot c_{t-1} + i_t \odot \tilde{c}_t = \theta_{t-1} - \alpha_t\nabla_{\theta_{t-1}}\mathcal{L}_t,<br />
\end{aligned}<br />
<br />
$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.<br />
<br />
$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ {{---}} не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.<br />
<br />
\begin{aligned}<br />
f_t &= \sigma(\mathbf{W}_f \cdot [\nabla_{\theta_{t-1}}\mathcal{L}_t, \mathcal{L}_t, \theta_{t-1}, f_{t-1}] + \mathbf{b}_f), & \scriptstyle{\text{как сильно мы забываем старые значения параметров}}\\<br />
i_t &= \sigma(\mathbf{W}_i \cdot [\nabla_{\theta_{t-1}}\mathcal{L}_t, \mathcal{L}_t, \theta_{t-1}, i_{t-1}] + \mathbf{b}_i), & \scriptstyle{\text{соответствует рейту обучения на шаге t}}\\<br />
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t, &\\<br />
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t, &\\<br />
\end{aligned}<br />
<br />
я ничего не понял..<br />
<br />
<h3>REPTILE</h3><br />
<br />
Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентный спуск и оба не чувствительны к модели.<br />
<br />
# сэмплируем задачу;<br />
# тренируемся на ней несколькими шагами градиентного спуска;<br />
# сдвигаем веса модели к новым параметрам.<br />
<br />
$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.<br />
<br />
<font color=green>// Algorithm REPTILE, batched version</font><br />
Initialize $\theta$<br />
'''for''' $iteration = 1, 2,...$ '''do'''<br />
Sample tasks $\tau_1, \tau_2, ..., \tau_n$<br />
'''for''' $i = 1, 2, ..., n$ '''do'''<br />
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$<br />
'''end for'''<br />
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$<br />
'''end for'''<br />
<br />
<h2>Определение множества конфигураций</h2><br />
Предшествующие вычисления могут быть также использованы для изучения пространства более успешных конфигураций $\theta\star$. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных ресурсах.<br />
<br />
Альтернативный подход сперва узнать оптимальные гиперпараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей на большом числе задач. После того, как уже проверены многие варианты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной. Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.<br />
<br />
Если мы хотим предоставить рекомендации для конкретной задачи $t_{new}$, нам нужна дополнительная информация о том, насколько $t_{new}$ похожа на предыдущие задачи $t_j$. Первый способ {{---}} посчитать число рекомендованных конфигураций для $t_{new}$, yielding новый эвиденс $\mathbf{P}_{new}$. Если позже мы будем наблюдать, что вычисления $P_{i,new}$ соответствуют $P_{i, j}$, то $t_{j}$ и $t_{new}$ могут быть очень похожими. Мы можем применить это знания для обучения meta-learner'a который предсказывает множество рекомендуемых конфигураций $\Theta^{*}_{new}$ для $t_{new}$.<br />
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_{new}$, перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.<br />
<br />
<h3>Relative landmarks</h3><br />
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.<br />
<br />
<h3>Суррогатные модели</h3><br />
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. <br />
<br />
Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.<br />
<br />
Так же можно обучать суррогатные модели на Гауссовских процессах (GP) для каждой предыдущей задачи и еще одну для $t_{new}$ и объединить их во взвешенную и нормализованную сумму с медианой $\mu$, определенной как взвешенная сумма $\mu_{j}$ полученных из задач $t_{j}$. Веса $\mu_{j}$ считаются через Nadaraya-Watson kernel-weighted average, где каждая задача представлена вектором relative landmarks и Epanechnikov quadratic kernel используется для определения похожести между векторами relative landmarks для $t_{j}$ и $t_{new}$. Чем больше $t_{j}$ похожа на $t_{new}$, тем больше получится вес $s_{j}$, увеличивающий влияние суррогатной модели для $t_{j}$.<br />
<br />
Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ получается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.<br />
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.<br />
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).<br />
<br />
<h3>Обучение на свойствах задачи (learning on task properties)</h3><br />
Каждая задача $t_{j} \in T$ может быть описана вектором $m(t_j) = (m_{j,1}, ...,m_{j,K})$ из $K$ мета-фичей $m_{j, k} \in M$, где $M$ {{---}} множество мета-фичей. Можно определить меру "похожести" задач, основанную, например, на Евклидовом расстоянии между $m(t_i)$ и $m(t_j)$, тогда можно будет использовать информацию из наиболее похожей задачи на новую задачу $t_{new}$. Более того используя предшествующие вычисления $\textbf{P}$ можно обучить meta-learner'a $L$ предсказывать производительность $P_{i, new}$ конфигураций $\theta_{i}$ на новых задачах $t_{new}$.<br />
<br />
$L: \Theta \times M \rightarrow \textbf{P},$<br />
<br />
В таблице представлен обзор наиболее используемых мета-фичей.<br />
<br />
{| class="wikitable"<br />
|+ Meta-feature<br />
|-<br />
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''<br />
|-<br />
| colspan="4" align="center" | '''simple'''<br />
|-<br />
| Nr instances || $n$ || Speed, Scalability<ref>[https://www1.maths.leeds.ac.uk~charlesstatlogwhole.pdf Donald Michie, David J. Spiegelhalter, Charles C. Taylor, and John Campbell. Machine Learning, Neural and Statistical Classification, 1994]</ref> || $p/n$, $log(n)$, log(n/p)<br />
|-<br />
| Nr features || $p$ || Curse of dimensionality || $log(p)$, % categorical<br />
|-<br />
| Nr classes || $c$ || Complexity, imbalance || ratio min/maj class<br />
|-<br />
| Nr missing values || $m$ || Imputation effects <ref>A. Kalousis. Algorithm Selection via Meta-Learning. PhD thesis, University of Geneva, Department of Computer Science, 2002</ref> || % missing<br />
|-<br />
| Nr outliers || $o$ || Data noisiness <ref>Peter J. Rousseeuw and Mia Hubert. Robust statistics for outlier detection. Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery, 2011.</ref> || $o/n$<br />
|-<br />
| colspan="4" align="center" | '''statistical'''<br />
|-<br />
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$<br />
|-<br />
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$<br />
|-<br />
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence || min,max,$\mu$,$\sigma$,$\rho_{XY}$<br />
|-<br />
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence || min,max,$\mu$,$\sigma$,$cov_{XY}$<br />
|-<br />
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence <ref>Alexandros Kalousis and Melanie Hilario. Model selection via meta-learning: a comparative study.Intl Journ. on Artificial Intelligence Tools, 2001.</ref> || min,max,$\mu$,$\sigma$,$\tau_{XY}$<br />
|-<br />
| Sparsity || sparsity(X) || Degree of discreteness <ref>Mostafa A. Salama, Aboul~Ella Hassanien, and Kenneth Revett. Employment of neural network and rough set in meta-learning, 2013.</ref> || min,max,$\mu$,$\sigma$<br />
|-<br />
| Gravity || gravity(X) || Inter-class dispersion <ref>Shawkat Ali and Kate~A. Smith-Miles. On learning algorithm selection for classification. Applied Soft Computing, 2006.</ref> ||<br />
|-<br />
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy || $p_{val_{XY}}$\citep{soares+04}<br />
|-<br />
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target <ref>C. Soares, P. Brazdil, and P. Kuba. A meta-learning method to select the kernel width in support vector regression, 2004.</ref> ||<br />
|-<br />
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{<re[https://www1.maths.leeds.ac.uk~charlesstatlogwhole.pdf]</ref>f>}<br />
|-<br />
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis<br />
|-<br />
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality <ref>R ́emi Bardenet, M ́aty ́as Brendel, Bal ́azs K ́egl, and Michele Sebag. Collaborative hyperparameter tuning. In Proceedings of ICML 2013, pages 199–207, 2013</ref> ||<br />
|-<br />
| Class probability || $P(\texttt{C})$ || Class distribution || min,max,$\mu$,$\sigma$<br />
|-<br />
| colspan="4" align="center" | '''informational-theoretic'''<br />
|-<br />
| Class entropy || $H(\texttt{C})$ || Class imbalance ||<br />
|-<br />
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness <ref>Ciro Castiello, Giovanna Castellano, and Anna~Maria Fanelli. Meta-data: {C}haracterization of input features for meta-learning, pages 457 -- 468, 2005.</ref> || min,max,$\mu$,$\sigma$<br />
|-<br />
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance || min,max,$\mu$,$\sigma$<br />
|-<br />
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || <ref>Feature importance A. Agresti. Categorical Data Analysis. Wiley Interscience, 2002.</ref> || min,max,$\mu$,$\sigma$<br />
|-<br />
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality ||<br />
|-<br />
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data ||<br />
|-<br />
| colspan="4" align="center" | '''complexity'''<br />
|-<br />
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ || <br />
|-<br />
| Volume of overlap || || Class distribution overlap <ref>Tin Kam Ho and Mitra Basu. Complexity measures of supervised classification problems. Pattern Analysis and Machine Intellig, 2002.</ref> || <br />
|-<br />
| Concept variation || || Task complexity <ref>R. Vilalta. Understanding accuracy performance through concept characterization and algorithm analysis. ICML Workshop on Recent Advances in Meta-Learning and Future Work, 1999.</ref> ||<br />
|-<br />
| Data consistency || || Data quality <ref>C K{\"o}pf and I Iglezakis. Combination of task description strategies and case base properties for meta-learning, 2002.</ref> ||<br />
|-<br />
| colspan="4" align="center" | '''model-based'''<br />
|- <br />
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity <ref>Y Peng, P Flach, C Soares, and P Brazdil. Improved dataset characterisation for meta-learning, 2002.</ref> || Tree depth<br />
|-<br />
| Branch length || || Concept complexity || min,max,$\mu$,$\sigma$<br />
|-<br />
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance || min,max,$\mu$,$\sigma$<br />
|-<br />
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity <ref>Andray Filchenkov and Arseniy Pendryak. Dataset metafeature description for recommending feature selection. In \emph{ISMW FRUCT}, pages 11--18, 2015.</ref> || min,max,$\mu$,$\sigma$<br />
|-<br />
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability <ref>Bernhard Pfahringer, Hilan Bensusan, and Christophe G. Giraud-Carrier. Meta-learning by landmarking various learning algorithms.In \emph{17th International Conference on Machine Learning (ICML), 2000.</ref> || min,max,$\mu$,$\sigma$<br />
|-<br />
| Information gain || || Feature importance || min,max,$\mu$,$\sigma$, gini<br />
|-<br />
| colspan="4" align="center" | '''landmarks'''<br />
|-<br />
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity <ref>Bernhard Pfahringer, Hilan Bensusan, and Christophe G. Giraud-Carrier. Meta-learning by landmarking various learning algorithms.In \emph{17th International Conference on Machine Learning (ICML)}, pages 743 -- 750, 2000.</ref> || See \citet{Pfahringer:2000p553}<br />
|-<br />
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability || Stump,RandomTree<br />
|-<br />
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability || Lin.Disciminant<br />
|-<br />
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence || See <ref>Daren Ler, Irena Koprinska, and Sanjay Chawla. Utilizing regression-based landmarkers within a meta-learning framework for algorithm selection. \emph{Technical Report 569. University of Sydney}, pages 44--51, 2005.</ref><br />
|-<br />
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance <ref>J F{\"u}rnkranz and J Petrak. An evaluation of landmarking variants. \emph{ECML/PKDD 2001 Workshop on Integrating Aspects of Data Mining, Decision Support and Meta-Learning}, pages 57--68, 2001.</ref> ||<br />
|-<br />
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance <ref>Taciana AF Gomes, Ricardo BC Prud{\^e}ncio, Carlos Soares, Andr{\'e} LD Rossi and Andr{\'e} Carvalho. Combining meta-learning and search techniques to select parameters for support vector machines, 2012.</ref> ||<br />
|-<br />
|}<br />
<br />
Непрерывные фичи $X$ и таргет $Y$ имеют медиану $\mu_{X}$, stdev $\sigma_{X}$, variance $\sigma^{2}_{X}$. Категориальные фичи $\texttt{X}$ и класс $\texttt{C}$ имеют категориальные значения $\pi_{i}$, условные вероятности $\pi_{i|j}$, совместные вероятности $\pi_{i,j}$, предельные вероятности $\pi_{i+}=\sum_{j}\pi_{ij}$, энтропию $H(\texttt{X})=-\sum_{i}\pi_{i+}log_{2}(\pi_{i+})$.<br />
<br />
Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей и должны быть агрегированы через min, max, $\mu$, $\sigma$, quartiles или гистограммами.<br />
<br />
Во время вычисления похожести задач важно нормализовать все мета-фичи [bardnet], использовать feature selection <ref>L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP. Lecture Notes in Computer Science, 1704:98–106, 1999.</ref> или использовать dimensionality reduction (PCA, например).<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
* https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem<br />
* https://arxiv.org/pdf/1810.03548.pdf<br />
* https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf<br />
* https://openreview.net/pdf?id=rJY0-Kcll<br />
* https://www1.maths.leeds.ac.uk/~charles/statlog/whole.pdf<br />
* https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf<br />
<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0_%D0%B8_%D0%B5%D1%91_%D0%B2%D1%8B%D0%B1%D0%BE%D1%80&diff=69650Модель алгоритма и её выбор2019-01-29T23:18:49Z<p>Dariyakovleva: </p>
<hr />
<div>==Понятие модели==<br />
Пусть дана обучающая выборка <tex>(X, Y)</tex>, где <tex> X </tex> {{---}} множество признаков, описывающих объекты, а <tex> Y </tex> {{---}} конечное множество меток.<br />
<br />
Пусть задана функция <tex> g: X \times \Theta \rightarrow Y </tex>, где <tex> \Theta </tex> {{---}} множество дополнительных параметров (весов) функции.<br />
<br />
Описанная выше функция <tex> g </tex> для фиксированного значения весов <tex> \theta \in \Theta </tex> называется '''решающим правилом'''.<br />
<br />
'''Модель''' {{---}} совокупность всех решающих правил, которые получаются путем присваивания весам всех возможных допустимых значений. <br />
<br />
Формально модель <tex> A = \{g(x, \theta) | \theta \in \Theta\} </tex>.<br />
<br />
Модель определяется множеством допустимых весов <tex> \Theta </tex> и структурой решающего правила <tex> g(x,\theta) </tex>.<br />
<br />
=== Понятие гиперпараметров модели ===<br />
'''Гиперпараметры модели''' {{---}} параметры, значения которых задается до начала обучения модели и не изменяется в процессе обучения. У модели может не быть гиперпараметров.<br />
<br />
'''Параметры модели''' {{---}} параметры, которые изменяются и оптимизируются в процессе обучения модели и итоговые значения этих параметров являются результатом обучения модели. <br />
<br />
Примерами гиперпараметров могут служить количество слоев нейронной сети, а также количество нейронов на каждом слое. Примерами параметров могут служить веса ребер нейронной сети.<br />
<br />
Для нахождения оптимальных гиперпараметров модели могут применяться различные алгоритмы [[Настройка гиперпараметров | настройки гиперпараметров]]<sup>[на 28.01.19 не создан]</sup>.<br />
<br />
=== Пример ===<br />
[[Файл:Linear-regression.png|300px|thumb|[http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F_%28%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%29 Рис 1. Пример линейной регрессии]]]<br />
В качестве примера модели приведем [[Линейная регрессия | линейную регрессию]]<sup>[на 28.01.19 не создан].<br />
<br />
Линейная регрессия задается следующей формулой:<br />
<br />
<tex> g(x, \theta) = \theta_0 + \theta_1x_1 + ... + \theta_kx_k = \theta_0 + \sum_{i=1}^k \theta_ix_i = \theta_0 + x^T\theta</tex>, где <tex> x^T = (x_1, x_2, ..., x_k) </tex> {{---}} вектор признаков, <br />
<br />
<tex> \theta = (\theta_1, \theta_2, ..., \theta_k)</tex> {{---}} веса модели, настраиваемые в процессе обучения.<br />
<br />
Гиперпараметром модели является число слагаемых в функции <tex> g(x, \theta) </tex>.<br />
<br />
Более подробный пример линейной регрессии можно посмотреть в статье [[Переобучение | переобучение]].<br />
<br />
== Задача выбора модели ==<br />
Пусть <tex> A </tex> {{---}} модель алгоритма, характеризующаяся гиперпараметрами <tex> \lambda = \{\lambda_1, ..., \lambda_m\}, \lambda_1 \in \Lambda_1, ..., \lambda_m \in \Lambda_m </tex>. Тогда с ней связано пространство гиперпараметров <tex> \Lambda = \Lambda_1 \times ... \times \Lambda_m </tex>. <br />
<br />
За <tex> A_{\lambda}</tex> обозначим алгоритм, то есть модель алгоритма, для которой задан вектор гиперпараметров <tex> \lambda \in \Lambda </tex>.<br />
<br />
Для выбора наилучшего алгоритма необходимо зафиксировать меру качества работы алгоритма. Назовем эту меру <tex> Q(A_{\lambda}, D) </tex>.<br />
<br />
Задачу выбора наилучшего алгоритма можно разбить на две подзадачи: подзадачу выбора лучшего алгоритма из портфолио и подзадачу настройки гиперпараметров.<br />
<br />
==== Подзадача выбора лучшего алгоритма из портфолио ====<br />
Дано некоторое множество алгоритмов с фиксированными структурными параметрами <tex> \mathcal{A} = \{A^1_{\lambda_1}, ..., A^m_{\lambda_m}\}</tex> и обучающая выборка <tex> D = \{d_1, ..., d_n\}</tex>. Здесь <tex> d_i = (x_i, y_i) \in (X, Y)</tex>. Требуется выбрать алгоритм <tex> A^*_{\lambda_*} </tex>, который окажется наиболее эффективным с точки зрения меры качества <tex> Q </tex>.<br />
==== Подзадача оптимизации гиперпараметров ====<br />
Подзадача оптимизации гиперпараметров заключается в подборе таких <tex> \lambda^* \in \Lambda </tex>, при которых заданная модель алгоритма <tex> A </tex> будет наиболее эффективна.<br />
<br />
Гиперпараметры могут выбираться из ограниченного множества или с помощью перебора из неограниченного множества гиперпараметров, это зависит от непосредственной задачи. Во втором случае актуален вопрос максимального времени, которое можно потратить на поиск наилучших гиперпараметров, так как чем больше времени происходит перебор, тем лучше гиперпараметры можно найти, но при этом может быть ограничен временной бюджет, из-за чего перебор придется прервать.<br />
<br />
=== Методы выбора модели ===<br />
Модель можно выбрать из некоторого множества моделей, проверив результат работы каждой модели из множества с помощью ручного тестирования, но ручное тестирование серьезно ограничивает количество моделей, которые можно перебрать, а также требует больших трудозатрат. Поэтому в большинстве случаев используются алгоритмы, позволяющие автоматически выбирать модель. Далее будут рассмотрены некоторые из таких алгоритмов.<br />
[[Файл:Scikit-learn-scheme.png|900px|thumb|[https://www.codeastar.com/choose-machine-learning-models-python/ Рис 2. Схема выбора модели в библиотеке scikit-learn для Python]]]<br />
==== Кросс-валидация ====<br />
Основная идея алгоритма кросс-валидации {{---}} разбить обучающую выборку на обучающую и тестовую, чтобы таким образом эмулировать наличие тестовой выборки, которая не участвует в обучении, но для которой известны правильные ответы. Более подробно про алгоритм кросс-валидации можно прочитать в [[Кросс-валидация | соответствующей статье]].<br />
<br />
Достоинства и недостатки кросс-валидации:<br />
# Ошибка в процедуре кросс-валидации является достаточно точной оценкой ошибки на генеральной совокупности;<br />
# Проведение кросс-валидации требует значительного времени на многократное повторное обучение алгоритмов и применимо лишь для «быстрых» алгоритмов машинного обучения;<br />
# Кросс-валидация плохо применима в задачах кластерного анализа и прогнозирования временных рядов.<br />
<br />
==== Мета-обучение ====<br />
Целью мета-обучения является решение задачи выбора алгоритма из портфолио алгоритмов для решения поставленной задачи без непосредственного применения каждого из них. Решение этой задачи в рамках мета-обучения сводится к задаче [https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D1%83%D1%87%D0%B8%D1%82%D0%B5%D0%BB%D0%B5%D0%BC обучения с учителем]. Для этого используется заранее отобранное множество наборов данных <tex> D </tex>. Для каждого набора данных <tex> d \in D </tex> вычисляется вектор мета-признаков, которые описывают свойства этого набора данных. Ими могут быть: число категориальных или численных признаков объеков в <tex> d </tex>, число возможных меток, размер <tex> d </tex> и [https://ieeexplore.ieee.org/document/7382962 многие другие], а еще эту статью можно найти вот [https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf тут]. Каждый алгоритм запускается на всех наборах данных из <tex> D </tex>. После этого вычисляется эмпирический риск, на основе которого формируются метки классов. Затем мета-классификатор обучается на полученных результатах. В качестве описания набора данных выступает вектор мета-признаков, а в качестве метки — алгоритм, оказавшийся самым эффективным с точки зрения заранее выбранной меры качества. <br />
<br />
Более подробно про мета-обучение можно почитать в [[Мета-обучение | соответствующей статье]].<br />
<br />
Достоинства и недостатки мета-обучения:<br />
# Алгоритм, обучающийся большое время, запускается меньшее количество раз, что сокращает время работы;<br />
# Точность алгоритма может быть ниже, чем при кросс-валидации.<br />
<br />
==== Теория Вапника-Червоненкиса ====<br />
Идея данной теории заключается в следующем: чем более «гибкой» является модель, тем хуже ее обобщающая способность. Данная идея базируется на том, что «гибкое» решающее правило способно настраиваться на малейшие шумы, содержащиеся в обучающей выборке.<br />
<br />
'''Емкость модели для задачи классификации''' {{---}} максимальное число объектов обучающей выборки, для которых при любом их разбиении на классы найдется хотя бы одно решающее правило, безошибочно их классифицирующее.<br />
<br />
По аналогии емкость обобщается на другие задачи машинного обучения.<br />
<br />
Очевидно, что чем больше емкость, тем более «гибкой» является модель и, соответственно, тем хуже. Значит нужно добиваться минимально возможного количества ошибок на обучении при минимальной возможной емкости.<br />
<br />
Существует формула Вапника, связывающая ошибку на обучении <tex> P_{train}(\theta) </tex>, емкость <tex> h(\theta) </tex> и ошибку на генеральной совокупности <tex> P_{test}(\theta) </tex>:<br />
<br />
<tex> P_{test}(\theta) <= P_{train}(\theta) + \sqrt{\frac{h(\Theta) * (\log{(\frac{2d}{h(\Theta)})} + 1) - \log{(\frac{\eta}{4})}}{n}} </tex>, где <tex> d </tex> {{---}} размерность пространства признаков.<br />
<br />
Неравенство верно с вероятностью <tex> 1 - \eta </tex> <tex> \forall \theta \in \Theta </tex>.<br />
<br />
Алгоритм выбора модели согласно теории Вапника-Червоненкиса: последовательно анализируя модели с увеличивающейся емкостью, необходимо выбирать модель с наименьшей верхней оценкой тестовой ошибки.<br />
<br />
Достоинства теории Вапника-Червоненкиса:<br />
# Серьезное теоретическое обоснование, связь с ошибкой на генеральной совокупности;<br />
# Теория продолжает развиваться и в наши дни.<br />
Недостатки теории Вапника-Червоненкиса:<br />
# Оценки ошибки на генеральной совокупности сильно завышены;<br />
# Для большинства моделей емкость не поддается оценке;<br />
# Многие модели с бесконечной емкостью показывают хорошие результаты на практике.<br />
<br />
== Существующие системы автоматического выбора модели ==<br />
===Автоматизированный выбор модели в библиотеке [https://www.ml4aad.org/wp-content/uploads/2018/07/automl_book_draft_auto-weka.pdf auto-WEKA] для Java===<br />
Библиотека используется для одновременного поиска оптимальной модели и оптимальных гиперпараметров модели для задач классификации и регрессии (начиная с версии 2.0).<br />
<br />
Библиотека позволяет автоматически выбирать из 27 базовых алгоритмов, 10 мета-алгоритмов и 2 ансамблевых алгоритмов лучший, одновременно настраивая его гиперпараметры при помощи алгоритма [https://www.ml4aad.org/automated-algorithm-design/algorithm-configuration/smac/ SMAC]. Решение достигается полным перебором: оптимизация гиперпараметров запускается на всех алгоритмах по очереди. Недостатком такого подхода является слишком большое время выбора модели.<br />
===Автоматизированный выбор модели в библиотеке [https://epistasislab.github.io/tpot/ Tree-base Pipeline Optimization Tool (TPOT)] для Python.===<br />
[[Файл:TPOT-scheme.jpeg|500px|thumb|[https://raw.githubusercontent.com/EpistasisLab/tpot/master/images/tpot-ml-pipeline.png Рис 3. Схема выбора модели в библиотеке TPOT]]]<br />
Библиотека используется для одновременного поиска оптимальной модели и оптимальных гиперпараметров модели для задачи классификации.<br />
<br />
Выбор модели осуществляется на основе конвейера, организованного в древовидной структуре. Каждая вершина дерева {{---}} один из четырех операторов конвейера (preprocessing, decomposition, feature selection, modelling). Каждый конвейер начинается с одной или нескольких копий входного набора данных, которые являются листьями дерева и которые подаются в операторы в соответствии со структурой конвейера. Данные модифицируются оператором в вершине и поступают на вход следующей вершины. В библиотеке используются генетические алгоритмы для нахождения лучших конвейеров.<br />
<br />
После поиска конвейера его также можно экспортировать в файл Python.<br />
<br />
===Автоматизированный выбор модели в библиотеке [https://automl.github.io/auto-sklearn/stable/ auto-sklearn] для Python===<br />
[[Файл:Auto-sklearn-scheme.png|500px|thumb|[https://papers.nips.cc/paper/5872-efficient-and-robust-automated-machine-learning.pdf Рис 4. Схема выбора модели в библиотеке auto-sklearn]]]<br />
Библиотека используется для одновременного поиска оптимальной модели и оптимальных гиперпараметров модели для задачи классификации.<br />
<br />
Сначала используется мета-обучение на основе различных признаков и мета-признаков набора данных, чтобы найти наилучшие модели. После этого используется подход [https://en.wikipedia.org/wiki/Bayesian_optimization Байесовской оптимизации], чтобы найти наилучшие гиперпараметры для наилучших моделей.<br />
<br />
== См. также ==<br />
* [[Настройка гиперпараметров]]<sup>[на 28.01.19 не создан]</sup><br />
* [[Переобучение]]<br />
* [[Мета-обучение]]<br />
* [[Линейная регрессия]]<sup>[на 28.01.19 не создан]<br />
<br />
== Примечания ==<br />
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%92%D0%B0%D0%BF%D0%BD%D0%B8%D0%BA%D0%B0-%D0%A7%D0%B5%D1%80%D0%B2%D0%BE%D0%BD%D0%B5%D0%BD%D0%BA%D0%B8%D1%81%D0%B0 Теория Вапника-Червоненкинса]<br />
# [https://en.wikipedia.org/wiki/Cross-validation_(statistics) Кросс-валидация]<br />
# [https://link.springer.com/article/10.1023/B:MACH.0000015878.60765.42 Мета-обучение]<br />
# [https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D1%83%D1%87%D0%B8%D1%82%D0%B5%D0%BB%D0%B5%D0%BC Обучение с учителем]<br />
# [https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F Линейная регрессия]<br />
# [https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf Datasets Meta-Feature Description for Recommending Feature Selection Algorithm]<br />
# [https://www.ml4aad.org/automated-algorithm-design/algorithm-configuration/smac/ SMAC]<br />
# [https://7bce9816-a-62cb3a1a-s-sites.googlegroups.com/site/automl2017icml/accepted-papers/AutoML_2017_paper_23.pdf?attachauth=ANoY7cr6uPaUoNh3gc3A-A1UbLXQgNEATEkfZmKD8kozB3hpCYtM9JwnOevEsW9W42CwurzJKrxxEatcB4DCjWNB_Ndvy1uC0lbQyCTlDIfrW6eYJXvdbFJPilYfmf8_ryilH0IwG0ddntLYy-VA3Fm1JeM495fTZxorYth0DDKiqtKvSR92dGl8CM_mUB7sun0R6wurCxM36QqcYEaf5kIm13MM0reWlR3aPZVNe_-AefOCpoXznR-wH04mSWjH8jmlk5Bw51AN&attredirects=0 Fast Automated Selection of Learning Algorithm And its Hyperparameters by Reinforcement Learning]<br />
# Shalamov V., Efimova V., Muravyov S., and Filchenkov A. "Reinforcement-based Method for Simultaneous Clustering Algorithm Selection and its Hyperparameters Optimization." Procedia Computer Science 136 (2018): 144-153.<br />
== Источники информации ==<br />
# [http://www.machinelearning.ru/wiki/images/0/05/BMMO11_4.pdf Выбор модели] - презентация на MachineLearning.ru<br />
# [https://en.wikipedia.org/wiki/Hyperparameter_(machine_learning) Гиперпараметры] - статья на Википедии<br />
# [https://machinelearningmastery.com/difference-between-a-parameter-and-a-hyperparameter/ Разница между параметрами и гиперпараметрами] - описание разницы между параметрами и гиперпараметрами модели<br />
# [http://jmlda.org/papers/doc/2016/no2/Efimova2016Reinforcement.pdf Применение обучения с подкреплением для одновременного выбора модели алгоритма классификации и ее структурных параметров]<br />
<br />
[[Категория: Автоматическое машинное обучение]]<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%89%D0%B8%D0%B5_%D0%BF%D0%BE%D0%BD%D1%8F%D1%82%D0%B8%D1%8F&diff=69649Общие понятия2019-01-29T23:09:14Z<p>Dariyakovleva: </p>
<hr />
<div>== Понятие машинного обучения в искусственном интеллекте ==<br />
Одним из первых, кто использовал термин "машинное обучение", был изобретатель первой самообучающейся компьютерной программы игры в шашки А. Л. Самуэль в 1959 г. <ref>[https://www.cs.virginia.edu/~evans/greatworks/samuel.pdf A.L. Samuel "Some Studies in Machine Learning Using the Game of Checkers" (IBM Journal. July 1959. P. 210–229)]</ref><br />
{{Определение<br />
|definition=<br />
'''Машинное обучение''' (англ. ''Machine learning'') {{---}} процесс, который даёт возможность компьютерам обучаться выполнять что-то без явного написания кода.<br />
}}<br />
Это определение не выдерживает критики, так как не понятно, что означает наречие "явно". Более точное определение дал намного позже Т. М. Митчелл. <ref>[https://www.cs.ubbcluj.ro/~gabis/ml/ml-books/McGrawHill%20-%20Machine%20Learning%20-Tom%20Mitchell.pdf T.M. Mitchell "Machine Learning" (McGraw-Hill, 1997) ]</ref><br />
{{Определение<br />
|definition=<br />
Компьютерная '''программа обучается''' на основе опыта $E$ по отношению к некоторому классу задач $T$ и меры качества $P$, если качество решения задач из $T$, измеренное на основе $P$, улучшается с приобретением опыта $E$. <br />
}}<br />
<br />
== Задача обучения ==<br />
$X$ {{---}} множество объектов (англ. '''object set''', or ''input set'') <br /><br />
$Y$ {{---}} множество меток классов (англ. '''label set''', or ''output set'') <br /><br />
$\hat y∶ X → Y$ {{---}} неизвестная зависимость (англ. '''unknown target function''' ''(dependency)'') <br /><br />
<br />
'''Дано''' <br /><br />
${x_1, . . . , x_l} ⊂ X$ {{---}} обучающая выбока (англ. ''training sample set'') <br /><br />
$y_i = \hat y(x_i), i = 1, . . . , l $ {{---}} известные метки классов <br /><br />
'''Найти''' <br /><br />
Найти $ a ∶ X → Y $ {{---}} алгоритм, решающую функцию (англ. '''decision function'''), приближающую $y$ на всём множестве $X$.<br />
=== Признаки ===<br />
Компьютер всегда имеет дело с признаковым описанием объектов. ''Например,'' пациента можно описать признаками: имя, возраст, номер полиса, жалобы, давление, температура, результаты анализов. <br /><br />
$f_j∶ X → D_j,j = 1, ... , n$ {{---}} признаки (англ. '''features''', or ''attributes'').<br />
<br />
Типы признаков:<br />
* бинарный (''binary''): $D_j = \{0, 1\}$;<br />
* номинальный, или категориальный (''categorical): $D_j$ конечно;<br />
* упорядоченный (''ordinal''): $D_j$ конечно и упорядоченно;<br />
* числовой (''numerical''): $D_j = \mathbb{R}$.<br />
<br />
т.е. объект представляется как набор признаков $(f_1(x),... ,f_n(x))$. Данные обычно представляются в виде матрицы объектов-признаков <br />
<br />
<tex><br />
F = ||f_j(x_i)||_{[l \times n]} = <br />
\begin{pmatrix}<br />
f_1(x_1) & \cdots & f_n(x_1) \\<br />
\cdots & \cdots & \cdots \\<br />
f_1(x_l) & \cdots & f_n(x_l) \\<br />
\end{pmatrix}<br />
</tex> <br /><br />
<br />
<br />
----<br />
<br />
=== Типы задач ===<br />
'''Задачи классификации''' (англ. ''classification''):<br />
* $Y = \{−1, +1\}$ — классификация на 2 класса;<br />
* $Y = \{1, . . . , M\}$ — на $M$ непересекающихся классов;<br />
* $Y = \{0, 1\}^M$— на $M$ классов, которые могут пересекаться.<br />
''Примеры:'' распознавание текста по рукописному вводу, определение того, находится на фотографии человек или кот.<br/><br />
'''Задачи восстановления регрессии''' (англ. ''regression''):<br />
{{main|Восстановление регрессии|l1=Восстановление регрессии<sup>[на 28.01.2019 не создан]</sup>}}<br />
* $Y = \mathbb{R}$ или $Y = \mathbb{R}^m$.<br />
''Примеры:'' предсказание стоимости акции через полгода, предсказание прибыли магазина в следующем месяце, предсказание качества вина на слепом тестировании.<br/><br />
'''Задачи ранжирования''' (англ. ''ranking''):<br />
* $Y$ {{---}} конечное упорядоченное множество.<br />
''Пример:'' выдача поискового запроса.<br/><br />
'''Задачи уменьшения размерности''' (англ. ''dimensionality reduction'') <br/><br />
{{main|Уменьшение размерности}}<br />
Научиться описывать данные не $N$ признаками, а меньшим числом для повышения точности модели или последующей визуализации. В качестве примера помимо необходимости для визуализации можно привести сжатие данных. <br/><br />
'''Задачи кластеризации''' (англ. ''cluster analysis'')<br/><br />
{{main|Кластеризация}}<br />
Разбиение данных множества объектов на подмножества ('''кластеры''') таким образом, чтобы объекты из одного кластера были более похожи друг на друга, чем на объекты из других кластеров по какому-либо критерию. <br/><br />
''Примеры:'' разбиение клиентов сотового оператора по платёжеспособности, разбиение космических объектов на похожие (галактики, планеты, звезды и так далее). <br/><br />
'''Задачи выявления аномалий''' (англ. ''anomaly detection'')<br/><br />
{{main|Выброс}}<br />
На основании признаков научиться различать отличать аномалии. Кажется, что от задачи классификации эта задача ничем не отличается. Но особенность выявления аномалий состоит в том, что примеров аномалий для тренировки модели у нас либо очень мало, либо нет совсем, поэтому мы не можем решать такую задачу как задачу классификации. <br/><br />
''Пример:'' определение мошеннических транзакций по банковской карте.<br />
<br />
== Классификация задач машинного обучения ==<br />
<br />
==== Обучение с учителем (англ. ''Supervised learning'' <ref> [http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D1%83%D1%87%D0%B8%D1%82%D0%B5%D0%BB%D0%B5%D0%BC Обучение с учителем]</ref>) ====<br />
Метки классов $y_i$ доступны все сразу (известны ответы для поставленной задачи).<br/><br />
''Задачи которые могут решаться этим способом:'' классификация, регрессия.<br />
<br />
==== Обучение без учителя (англ. ''Unsupervised learning'') ====<br />
Изучает широкий класс задач обработки данных, в которых известны только описания множества объектов (обучающей выборки), и требуется обнаружить внутренние взаимосвязи, зависимости, закономерности, существующие между объектами. Т.е. тренировочные данные доступны все сразу, но ответы для поставленной задачи неизвестны. <br />
<br />
''Задачи, которые могут решаться этим способом:'' кластеризация, нахождение ассоциативных правил, выдача рекомендаций (например, реклама), уменьшение размерности датасета.<br />
<br />
==== Обучение с частичным привлечением учителя (англ. ''Semi-supervised learning''<ref>[http://www.machinelearning.ru/wiki/index.php?title=%D0%A7%D0%B0%D1%81%D1%82%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5 Semi-supervised learning]</ref>) ====<br />
Занимает промежуточное положение между обучением с учителем и без учителя. Каждый прецедент представляет собой пару «объект, ответ», но ответы известны только на части прецедентов (Размечено мало, либо малоинформативная часть).<br/><br />
''Примером частичного обучения может послужить сообучение:'' два или более обучаемых алгоритма используют один и тот же набор данных, но каждый при обучении использует различные — в идеале некоррелирующие — наборы признаков объектов.<br />
<br />
==== Обучение с подкреплением (англ. ''Reinforcement learning'') ====<br />
{{main|Обучение с подкреплением}}<br />
Частный случай обучения с учителем, сигналы подкрепления (правильности ответа) выдаются не учителем, а некоторой средой, с которой взаимодействует программа. Размеченность данных зависит от среды.<br />
<br />
Окружение обычно формулируется как марковский процесс принятия решений (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием. Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие суб оптимальных решений (дающих локальный экстремум) не ограничивается явно. Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний.<br />
<br />
==== Активное обучение (англ. ''Active learning'') ====<br />
{{main|Активное обучение}}<br />
Отличается тем, что обучаемый имеет возможность самостоятельно назначать следующий прецедент, который станет известен. Применяется когда получение истиной метки для объекта затруднительно. Поэтому алгоритм должен уметь определять, на каких объектах ему надо знать ответ,<br />
чтобы лучше всего обучиться, построить наилучшую модель.<br />
<br />
==== Обучение в реальном времени (англ. ''Online learning'') ====<br />
Может быть как обучением с учителем, так и без учителя. Специфика в том, что тренировочные данные поступают последовательно. Требуется немедленно принимать решение по каждому прецеденту и одновременно доучивать модель зависимости с учётом новых прецедентов. Здесь существенную роль играет фактор времени.<br />
<br />
== Примеры задач ==<br />
* '''Предсказание месторождений полезных ископаемых''' <br/><br />
''Признаками'' являются данные геологической разведки. <br />
* ''Бинарные признаки:'' наличие/отсутствие тех или иных пород на территории района;<br />
* ''Числовые признаки:'' физико-химические свойства пород можно описать количественной характеристикой.<br />
<br />
''Обучающая выборка'' состоит из двух классов:<br />
* районы известных месторождений; <br />
* похожие районы, в которых интересующее ископаемое обнаружено не было.<br />
<br />
При поиске редких полезных ископаемых количество объектов может оказаться намного меньше, чем количество признаков. В этой ситуации плохо работают классические статистические методы. Задача решается путём поиска закономерностей в имеющемся массиве данных. В процессе решения выделяются короткие наборы признаков, обладающие наибольшей ''информативностью'' — способностью наилучшим образом разделять классы (''"синдромы"'' месторождений). <br />
* '''Оценивание кредитоспособности заёмщиков''' <br/><br />
Эта задача решается банками при выдаче кредитов. Объектами в данном случае являются физические или юридические лица, претендующие на получение кредита.<br />
<br />
В случае физических лиц признаковое описание состоит из:<br />
* анкеты, которую заполняет сам заёмщик;<br />
* дополнительной информации, которую банк собирает о нём из собственных источников.<br />
<br />
Можно выделить следующие ''признаки'':<br />
* ''Бинарные признаки:'' пол, наличие телефона; <br />
* ''Номинальные признаки:'' место проживания, профессия, работодатель; <br />
* ''Порядковые признаки:'' образование, занимаемая должность; <br />
* ''Числовые признаки:''сумма кредита, возраст, стаж работы, доход семьи, размер задолженностей в других банках.<br />
<br />
''Обучающая выборка'' составляется из заёмщиков с известной кредитной историей. <br />
<br />
На стадии обучения производится синтез и отбор информативных признаков и определяется, сколько баллов назначать за каждый признак, чтобы риск принимаемых решений был минимален. Чем выше суммарное число баллов заёмщика, набранных по совокупности информативных признаков, тем более надёжным считается заёмщик. <br />
* '''Задачи медицинской диагностики''' <br/><br />
В роли ''объектов'' выступают пациенты. Признаки характеризуют результаты обследований, симптомы заболевания и применявшиеся методы лечения.<br />
<br />
* ''Бинарные признаки'': пол, наличие головной боли, слабости; <br />
* ''Порядковый признак'': тяжесть состояния (удовлетворительное, средней тяжести, тяжёлое, крайне тяжёлое);<br />
* ''Числовые признаки :''возраст, пульс, артериальное давление, содержание гемоглобина в крови, доза препарата. <br />
<br />
Признаковое описание пациента является, по сути дела, формализованной историей болезни.<br />
<br />
Накопив достаточное количество данных, можно решать различные задачи:<br />
* классифицировать вид заболевания (дифференциальная диагностика);<br />
* определять наиболее целесообразный способ лечения;<br />
* предсказывать длительность и исход заболевания;<br />
* оценивать риск осложнений;<br />
* находить наиболее характерные для данного заболевания совокупности симптомов. <br />
<br />
Ценность такого рода систем в том, что они способны мгновенно анализировать и обобщать огромное количество прецедентов — возможность, недоступная специалисту-врачу. <br />
<br />
* '''Задача классификации видов ириса (Фишер 1936)''' <ref>[https://ru.wikipedia.org/wiki/%D0%98%D1%80%D0%B8%D1%81%D1%8B_%D0%A4%D0%B8%D1%88%D0%B5%D1%80%D0%B0 Задача классификации видов ириса]</ref> <ref>[http://edu.mmcs.sfedu.ru/pluginfile.php/17198/mod_resource/content/1/01%20%D0%9E%D1%81%D0%BD%D0%BE%D0%B2%D0%BD%D1%8B%D0%B5%20%D0%BF%D0%BE%D0%BD%D1%8F%D1%82%D0%B8%D1%8F.pdf Презентация "Основные понятия машинного обучения"]</ref><br/> <br />
[[Файл:Iris_classification.png|650px]]<br />
<br />
== Открытые наборы данных для обучения ==<br />
{{main|Известные наборы данных|l1=Известные наборы данных<sup>[на 28.01.2019 не создан]</sup>}}<br />
==== Компьютерное зрение ====<br />
* [https://pjreddie.com/projects/mnist-in-csv/ MNIST]: один из самых востребованных наборов для проверки работоспособности. Есть датасеты 25x25, отцентрованные, рукописные чёрно-былые цифры;<br />
* [https://www.cs.toronto.edu/~kriz/cifar.html CIFAR10 & CIFAR100]: цветные изображения 32x32. Сегодня используется нечасто, но может быть хорошим вариантов для проверки работоспособности;<br />
* [http://image-net.org/ ImageNet]: датасет изображений для проверки новых алгоритмов.<br />
<br />
==== Естественные языки ====<br />
* [https://blog.einstein.ai/the-wikitext-long-term-dependency-language-modeling-dataset/ WikiText]: большой свод данных для языкового моделирования из статей Википедии, собранный Salesforce MetaMind.<br />
==== Речь ====<br />
* [http://www.openslr.org/12/ LibriSpeech]: около 500 часов начитки аудиокниг, в исполнении разных людей. Данные организованы по главам книг, содержат текст и записи.<br />
==== Системы рекомендаций и ранжирования ====<br />
* [https://www.kaggle.com/c/msdchallenge Million Song Dataset]: большой open source-датасет [https://www.kaggle.com/ Kaggle], насыщенный метаданными. Хороший вариант для тех, кто экспериментирует с гибридными системами рекомендаций.<br />
==== Сети и графы ====<br />
* [http://snap.stanford.edu/data/#amazon Amazon Co-Purchasing] и [http://snap.stanford.edu/data/amazon-meta.html Amazon Reviews]: данные, собранные из раздела «Пользователи, купившие это, также выбирают…» на Amazon, а также обзоры сопутствующих товаров. Хорош для экспериментов рекомендательными системами в соцсетях.<br />
==== Геопространственные данные ====<br />
* [http://wiki.openstreetmap.org/wiki/Planet.osm OpenStreetMap]: векторные картографические данные для всей планеты, с бесплатной лицензией. Включает в себя старую версию данных TIGER Бюро переписи США.<br />
<br />
== См. также ==<br />
* [[Переобучение]]<br />
* [[Модель алгоритма и ее выбор]]<br />
* [[Оценка качества в задаче кластеризации]]<br />
* [[Кросс-валидация]]<br />
* [[Обзор библиотек для машинного обучения на Python]]<br />
<br />
== Примечания ==<br />
<references /><br />
<br />
== Источники информации ==<br />
#[https://en.wikipedia.org/wiki/Machine_learning Машинное обучение] {{---}} Wiki<br />
#[http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%28%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2%29 Курс лекций по машинному обучению] {{---}} Воронцов К.В.<br />
#[https://newtonew.com/tech/machine-learning-novice Статья "Машинное обучение для чайников"]<br />
#[https://golos.io/ru--programmirovanie/@randall/kak-ii-nauchit-vsemu-luchshie-otkrytye-nabory-dannykh-dlya-obucheniya Статья "Лучшие наборы данных для обучения"]<br />
<br />
[[Категория: Машинное обучение]]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68754Обучение с подкреплением2019-01-21T22:06:38Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment''), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти стратегию, приписывающую состояниям (''states'') окружающей среды действия, одно из которых может выбрать агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit о многоруком бандите].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex><br />
* множества действий (''actions'') <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'')<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://econophysica.ru/services/machine-learning/|Взаимодействие агента со средой]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> {{---}} функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> {{---}} функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> {{---}} learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> {{---}} discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q is not converged:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s is not terminated:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68752Обучение с подкреплением2019-01-21T22:03:24Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment''), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти стратегию, приписывающую состояниям (''states'') окружающей среды действия, одно из которых может выбрать агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit о многоруком бандите].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex><br />
* множества действий (''actions'') <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'')<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://econophysica.ru/services/machine-learning/|Взаимодействие агента со средой]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:RL.png&diff=68751Файл:RL.png2019-01-21T22:01:24Z<p>Dariyakovleva: Dariyakovleva загрузил новую версию Файл:RL.png</p>
<hr />
<div></div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68750Обучение с подкреплением2019-01-21T21:56:04Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment''), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти стратегию, приписывающую состояниям (''states'') окружающей среды действия, одно из которых может выбрать агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit о многоруком бандите].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex><br />
* множества действий (''actions'') <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'')<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://skymind.ai/wiki/deep-reinforcement-learning|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68749Обучение с подкреплением2019-01-21T21:55:38Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment''), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти стратегию, приписывающую состояниям (''states'') окружающей среды действия, одно из которых может агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit о многоруком бандите].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex><br />
* множества действий (''actions'') <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'')<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://skymind.ai/wiki/deep-reinforcement-learning|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68743Обучение с подкреплением2019-01-21T21:12:43Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment''), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти стратегию, приписывающую состояниям (''states'') окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex><br />
* множества действий (''actions'') <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'')<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://skymind.ai/wiki/deep-reinforcement-learning|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68742Обучение с подкреплением2019-01-21T21:11:00Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment'')), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' (''states'')) окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (англ. ''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex><br />
* множества действий (''actions'') <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'')<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://skymind.ai/wiki/deep-reinforcement-learning|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''greedy & <tex>\epsilon</tex>-greedy'') === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68741Обучение с подкреплением2019-01-21T21:10:30Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент (''agent'') взаимодействует с окружающей средой (''environment'')), предпринимая действия (''actions''). Окружающая среда дает награду (''reward'') за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' (''states'')) окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (англ. ''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения (''states'') <tex>S</tex><br />
* множества действий (''actions'') <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей" (''rewards'')<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://skymind.ai/wiki/deep-reinforcement-learning|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями] (''temporal difference (TD) learning'').<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите (''The multi-armed bandit problem'') == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии (''''greedy & <tex>\epsilon</tex>-greedy) === <br />
<br />
==== Жадная (''greedy'') стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-''greedy'') стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (''upper confidence bound'') === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[https://login.cs.utexas.edu/sites/default/files/legacy_files/research/documents/1%20intro%20up%20to%20RL%3ATD.pdf Sutton, Richard S., and Andrew G. Barto. Introduction to reinforcement learning. Vol. 135. Cambridge: MIT press, 1998.]<br />
*[https://web.stanford.edu/class/psych209/Readings/SuttonBartoIPRLBook2ndEd.pdf Sutton R. S., Barto A. G. Reinforcement learning: An introduction. – 2011.]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68740Обучение с подкреплением2019-01-21T20:59:45Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент взаимодействует с окружающей средой, предпринимая действия. Окружающая среда его поощряет за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (англ. ''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|link=https://skymind.ai/wiki/deep-reinforcement-learning|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|link=http://toppromotion.ru/blog/seo-category/novyij-algoritm-pod-nazvaniem-%C2%ABmnogorukij-bandit%C2%BB.html|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
=== Жадные и <tex>\epsilon</tex>-жадные стратегии === <br />
<br />
==== Жадная (greedy) стратегия ====<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
==== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ====<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
=== Стратегия Softmax === <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
=== Метод UCB (upper confidence bound) === <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|link=https://en.wikipedia.org/wiki/Q-learning|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68738Обучение с подкреплением2019-01-21T20:52:36Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент взаимодействует с окружающей средой, предпринимая действия. Окружающая среда его поощряет за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (англ. ''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
== Жадные и <tex>\epsilon</tex>-жадные стратегии == <br />
<br />
=== Жадная (greedy) стратегия ===<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
=== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ===<br />
<br />
[[File:Eps-greedy.png|thumb|313px|link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
== Стратегия Softmax == <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
== Метод UCB (upper confidence bound) == <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68737Обучение с подкреплением2019-01-21T20:50:57Z<p>Dariyakovleva: </p>
<hr />
<div>{{Определение<br />
|definition=<br />
'''Обучение с подкреплением''' (англ. ''reinforcement learning'') {{---}} способ машинного обучения, при котором система обучается, взаимодействуя с некоторой средой.<br />
}}<br />
<br />
== Обучение с подкреплением == <br />
<br />
В обучении с подкреплением существует агент взаимодействует с окружающей средой, предпринимая действия. Окружающая среда его поощряет за эти действия, а агент продолжает их предпринимать.<br />
<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний (англ. ''exploration vs exploitation'').<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 1</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma \in (0, 1)</tex> {{---}} усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > \in (0, 1)</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий'' (ручек автомата)<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие (ручку) <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> {{---}} средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> {{---}} ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> ручек автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation''-''exploration''.<br />
<br />
== Жадные и <tex>\epsilon</tex>-жадные стратегии == <br />
<br />
=== Жадная (greedy) стратегия ===<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
=== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ===<br />
<br />
[[File:Eps-greedy.png|thumb|313px|Пример. Награда для стратегии с различными <tex>\epsilon</tex> link=https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выберем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
== Стратегия Softmax == <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (exploration).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (exploitation).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
== Метод UCB (upper confidence bound) == <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68360Обучение с подкреплением2019-01-13T21:59:08Z<p>Dariyakovleva: </p>
<hr />
<div>== Обучение с подкреплением == <br />
'''Обучение с подкреплением''' {{---}} подраздел [[машинное обучение|машинного обучения]], изучающий как ''агент'' должен ''действовать'' в ''среде'', чтобы максимизировать некоторый долговременный ''выигрыш''.<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний.<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 0</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma > 0</tex> — усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > 0</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий''<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> — средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> — ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> рук автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a)</tex> <tex>\forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
Задача является модельной для понимания конфликта между ''exploitation'' (применение, эксплуатация) и ''exploration'' (изучение, исследование).<br />
<br />
== Жадные и <tex>\epsilon</tex>-жадные стратегии == <br />
<br />
=== Жадная (greedy) стратегия ===<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
=== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ===<br />
<br />
[[File:Eps-greedy.png|thumb|313px|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выбирем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
== Стратегия Softmax == <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (режим исследования).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (режим эксплуатации).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
== Метод UCB (upper confidence bound) == <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68359Обучение с подкреплением2019-01-13T21:54:51Z<p>Dariyakovleva: </p>
<hr />
<div>== Обучение с подкреплением == <br />
'''Обучение с подкреплением''' {{---}} подраздел [[машинное обучение|машинного обучения]], изучающий как ''агент'' должен ''действовать'' в ''среде'', чтобы максимизировать некоторый долговременный ''выигрыш''.<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний.<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 0</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma > 0</tex> — усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > 0</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий''<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> — средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> — ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> рук автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a) \forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
TODO пока очень тупо<br />
<br />
Задача является модельной для понимания конфликта между ''exploitation'' (применение, эксплуатация) и ''exploration'' (изучение, исследование).<br />
<br />
== Жадные и <tex>\epsilon</tex>-жадные стратегии == <br />
<br />
TODO<br />
<br />
=== Жадная (greedy) стратегия ===<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
=== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ===<br />
<br />
[[File:Eps-greedy.png|thumb|313px|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выбирем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
== Стратегия Softmax == <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (режим исследования).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (режим эксплуатации).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
== Метод UCB (upper confidence bound) == <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68358Обучение с подкреплением2019-01-13T21:53:34Z<p>Dariyakovleva: </p>
<hr />
<div>== Обучение с подкреплением == <br />
'''Обучение с подкреплением''' {{---}} подраздел [[машинное обучение|машинного обучения]], изучающий как ''агент'' должен ''действовать'' в ''среде'', чтобы максимизировать некоторый долговременный ''выигрыш''.<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний.<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 0</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma > 0</tex> — усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > 0</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий''<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> — средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> — ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> рук автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a) \forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
TODO пока очень тупо<br />
<br />
Задача является модельной для понимания конфликта между ''exploitation'' (применение, эксплуатация) и ''exploration'' (изучение, исследование).<br />
<br />
== Жадные и <tex>\epsilon</tex>-жадные стратегии == <br />
<br />
TODO<br />
<br />
=== Жадная (greedy) стратегия ===<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax\limits_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
=== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ===<br />
<br />
[[File:Eps-greedy.png|thumb|313px|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выбирем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
== Стратегия Softmax == <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (режим исследования).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (режим эксплуатации).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
== Метод UCB (upper confidence bound) == <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68357Обучение с подкреплением2019-01-13T21:46:55Z<p>Dariyakovleva: </p>
<hr />
<div>== Обучение с подкреплением == <br />
'''Обучение с подкреплением''' {{---}} подраздел [[машинное обучение|машинного обучения]], изучающий как ''агент'' должен ''действовать'' в ''среде'', чтобы максимизировать некоторый долговременный ''выигрыш''.<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний.<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 0</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma > 0</tex> — усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > 0</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий''<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> — средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> — ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> рук автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a) \forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
TODO пока очень тупо<br />
<br />
Задача является модельной для понимания конфликта между ''exploitation'' (применение, эксплуатация) и ''exploration'' (изучение, исследование).<br />
<br />
== Жадные и <tex>\epsilon</tex>-жадные стратегии == <br />
<br />
TODO<br />
<br />
=== Жадная (greedy) стратегия ===<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex> <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax \limits_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
=== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ===<br />
<br />
[[File:Eps-greedy.png|thumb|313px|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выбирем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
== Стратегия Softmax == <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (режим исследования).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (режим эксплуатации).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
== Метод UCB (upper confidence bound) == <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovlevahttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC&diff=68356Обучение с подкреплением2019-01-13T21:45:08Z<p>Dariyakovleva: </p>
<hr />
<div>== Обучение с подкреплением == <br />
'''Обучение с подкреплением''' {{---}} подраздел [[машинное обучение|машинного обучения]], изучающий как ''агент'' должен ''действовать'' в ''среде'', чтобы максимизировать некоторый долговременный ''выигрыш''.<br />
Алгоритмы с частичным обучением пытаются найти ''стратегию'', приписывающую ''состояниям'' окружающей среды действия, которые должен предпринять агент в этих состояниях.<br />
<br />
Среда обычно формулируется как [http://en.wikipedia.org/wiki/Markov_decision_process марковский процесс принятия решений] (МППР) с конечным множеством состояний, и в этом смысле алгоритмы обучения с подкреплением тесно связаны с динамическим программированием.<br />
Вероятности выигрышей и перехода состояний в МППР обычно являются величинами случайными, но стационарными в рамках задачи.<br />
<br />
При обучении с подкреплением, в отличии от обучения с учителем, не предоставляются верные пары "входные данные-ответ", а принятие субоптимальнх решений (дающих локальный экстремум) не ограничивается явно.<br />
Обучение с подкреплением пытается найти компромисс между исследованием неизученных областей и применением имеющихся знаний.<br />
Баланс изучения-применения при обучении с подкреплением исследуется в задаче [http://en.wikipedia.org/wiki/Multi-armed_bandit многорукого бандита].<br />
<br />
Формально простейшая модель обучения с подкреплением состоит из:<br />
* множества состояний окружения <tex>S</tex><br />
* множества действий <tex>A</tex><br />
* множества вещественнозначных скалярных "выигрышей"<br />
<br />
В произвольный момент времени <tex>t</tex> агент характеризуется состоянием <tex>s_t \in S</tex> и множеством возможных действий <tex>A(s_t)</tex>.<br />
Выбирая действие <tex>a \in A(s_t)</tex>, он переходит в состояние <tex>s_{t+1}</tex> и получает выигрыш <tex>r_t</tex>.<br />
Основываясь на таком взаимодействии с окружающей средой, агент, обучающийся с подкреплением, должен выработать стратегию <tex>\pi: S \to A</tex>, которая максимизирует величину <tex>R=r_0 + r_1+\cdots+r_n</tex> в случае МППР, имеющего терминальное состояние, или величину:<br />
<br />
::<tex>R=\sum_t \gamma^t r_t</tex><br />
<br />
для МППР без терминальных состояний (где <tex>0 \leq \gamma \leq 1</tex> {{---}} дисконтирующий множитель для "предстоящего выигрыша").<br />
<br />
Таким образом, обучение с подкреплением особенно хорошо подходит для решения задач, связанных с выбором между долгосрочной и краткосрочной выгодой.<br />
<br />
=== Постановка задачи обучения с подкреплением ===<br />
<br />
[[File:RL.png|thumb|RL-схема]]<br />
<br />
<tex>S</tex> {{---}} множество состояний среды<br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a | s)</tex> и состояния среды <tex>s_1</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a | s_t)</tex><br />
** среда генерирует награду <tex>r_{t + 1} ∼ p(r | a_t, s_t)</tex> и новое состояние <tex>s_{t + 1} ∼ p(s | a_t, s_t)</tex><br />
** агент корректирует стратегию <tex>\pi_{t + 1}(a | s)</tex><br />
<br />
Это марковский процесс принятия решений (МППР), если <br />
<tex>P(s_{t+1} = s′, r_{t+1} = r | s_t, a_t, r_t, s_{t−1}, a_{t−1}, r_{t−1}, .. ,s_1, a_1) = P(s_{t+1} = s′,r_{t+1} = r | s_t, a_t)</tex><br />
<br />
МППР называется финитным, если <tex>|A| < \infty</tex>, <tex>|S| < \infty</tex><br />
<br />
== Алгоритмы ==<br />
<br />
Теперь, когда была определена функция выигрыша, нужно определить алгоритм, который будет использоваться для нахождения стратегии, обеспечивающей наилучший результат.<br />
<br />
Наивный подход к решению этой задачи подразумевает следующие шаги:<br />
* опробовать все возможные стратегии<br />
* выбрать стратегию с наибольшим ожидаемым выигрышем<br />
<br />
Первая проблема такого подхода заключается в том, что количество доступных стратегий может быть очень велико или бесконечно.<br />
Вторая проблема возникает, если выигрыши стохастические — чтобы точно оценить выигрыш от каждой стратегии потребуется многократно применить каждую из них.<br />
Этих проблем можно избежать, если допустить некоторую структуризацию и, возможно, позволить результатам, полученным от пробы одной стратегии, влиять на оценку для другой.<br />
Двумя основными подходами для реализации этих идей являются оценка функций полезности и прямая оптимизация стратегий.<br />
<br />
Подход с использованием функции полезности использует множество оценок ожидаемого выигрыша только для одной стратегии <tex>\pi</tex> (либо текущей, либо оптимальной).<br />
При этом пытаются оценить либо ожидаемый выигрыш, начиная с состояния <tex>s</tex>, при дальнейшем следовании стратегии <tex>\pi</tex>,<br />
<br />
::<tex>V(s) = E[R|s, \pi]</tex>,<br />
<br />
либо ожидаемый выигрыш, при принятии решения <tex>a</tex> в состоянии <tex>s</tex> и дальнейшем соблюдении <tex>\pi</tex>,<br />
<br />
::<tex>Q(s, a) = E[R|s, \pi, a]</tex>.<br />
<br />
Если для выбора оптимальной стратегии используется функция полезности <tex>Q</tex>, то оптимальные действия всегда можно выбрать как действия, максимизирующие полезность.<br />
<br />
Если же мы пользуемся функцией <tex>V</tex>, необходимо либо иметь модель окружения в виде вероятностей <tex>P(s'|s, a)</tex>, что позволяет построить функцию полезности вида<br />
<br />
::<tex>Q(s, a) = \sum_{s'}V(s')P(s'|s, a)</tex>,<br />
<br />
либо применить т.н. метод исполнитель-критик, в котором модель делится на две части: критик, оценивающий полезность состояния <tex>V</tex>, и исполнитель, выбирающий подходящее действие в каждом состоянии.<br />
<br />
Имея фиксированную стратегию <tex>\pi</tex>, оценить <tex>E[R|\cdot]</tex> при <tex>\gamma = 0</tex> можно просто усреднив непосредственные выигрыши.<br />
Наиболее очевидный способ оценки при <tex>\gamma > 0</tex> — усреднить суммарный выигрыш после каждого состояния.<br />
Однако для этого требуется, чтобы МППР достиг терминального состояния (завершился).<br />
<br />
Поэтому построение искомой оценки при <tex>\gamma > 0</tex> неочевидно. Однако, можно заметить, что <tex>R</tex> образуют рекурсивное уравнение Беллмана:<br />
<br />
::<tex>E[R|s_t]=r_t + \gamma E[R|s_{t+1}]</tex>.<br />
<br />
Подставляя имеющиеся оценки, <tex>V</tex>, и применяя метод градиентного спуска с квадратичной функцией ошибок, мы приходим к алгоритму [http://en.wikipedia.org/wiki/Temporal_difference_learning обучения с временными воздействиями].<br />
В простейшем случае и состояния, и действия дискретны и можно придерживаться табличных оценок для каждого состояния.<br />
<br />
Другие похожие методы: Адаптивный эвристический критик (Adaptive Heuristic Critic, AHC), [http://en.wikipedia.org/wiki/SARSA SARSA] и Q-обучение ([http://en.wikipedia.org/wiki/Q-Learning Q-learning]).<br />
<br />
== Задача о многоруком бандите == <br />
<br />
[[File:bandit.jpg|thumb|Многорукий бандит]]<br />
<br />
=== Формулировка ===<br />
<br />
<tex>A</tex> {{---}} множество возможных ''действий''<br />
<br />
<tex>p_a(r)</tex> {{---}} неизвестное распределение ''награды'' <tex>r \in R</tex> <tex>\forall a \in A</tex><br />
<br />
<tex>\pi_t(a)</tex> {{---}} ''стратегия'' агента в момент <tex>t</tex> <tex>\forall a \in A</tex><br />
<br />
Игра агента со средой:<br />
* инициализация стратегии <tex>\pi_1(a)</tex><br />
* для всех <tex>t = 1 \ldots T</tex><br />
** агент выбирает действие <tex>a_t ∼ \pi_t(a)</tex><br />
** среда генерирует награду <tex>r_t ∼ p_{a_t}(r)</tex><br />
** агент корректирует стратегию <tex>\pi_{t+1}(a)</tex><br />
<br />
<tex>Q_t(a) = \frac{\sum^{t}_{i=1}{r_i[a_i = a]}}{\sum^{t}_{i=1}{[a_i = a]}} \rightarrow max </tex> — средняя награда в <i>t</i> играх <br /><br />
<tex>Q^∗(a) = \lim \limits_{t \rightarrow \infty} Q_t(a) \rightarrow max </tex> — ценность действия <tex>a</tex><br />
<br />
У нас есть автомат {{---}} <tex>N</tex>-рукий бандит, на каждом шаге мы выбираем за какую из <tex>N</tex> рук автомата дернуть,<br />
т.е. множество действий <tex>A = {1,2 \ldots ,N}</tex>.<br />
<br />
Выбор действия <tex>a_t</tex> на шаге <tex>t</tex> влечет награду <tex>R(a_t)</tex> при этом <tex>R(a) \forall a \in A</tex> есть случайная величина, распределение которой неизвестно.<br />
<br />
Состояние среды у нас от шага к шагу не меняется, а значит множество состояний <tex>S</tex> тривиально, ни на что не влияет, поэтому его можно проигнорировать.<br />
<br />
Для простоты будем полагать, что каждому действию соответствует некоторое распределение, которое не меняется со временем. Если бы мы знали эти распределения, то очевидная стратегия заключалась бы в том, чтобы подсчитать математическое ожидание для каждого из распределений, выбрать действие с максимальным математическим ожиданием и теперь совершать это действие на каждом шаге.<br />
<br />
Проблема в том, что распределения неизвестны, однако можно оценить математическое ожидание некоторой случайной величины <tex>\xi</tex> c неизвестным распределением. Для <tex>K</tex> экспериментов <tex>\xi_k</tex>, оценка математического ожидания это среднее арифметическое результатов экспериментов:<br />
<br />
<tex>E(\xi) = \frac{1}{K} \sum_{k=1}^{K}{\xi_k} </tex><br />
<br />
TODO пока очень тупо<br />
<br />
Задача является модельной для понимания конфликта между ''exploitation'' (применение, эксплуатация) и ''exploration'' (изучение, исследование).<br />
<br />
== Жадные и <tex>\epsilon</tex>-жадные стратегии == <br />
<br />
TODO<br />
<br />
=== Жадная (greedy) стратегия ===<br />
<br />
* <tex>P_a = 0</tex> <tex>\forall a \in \{1 \ldots N\} </tex> {{---}} сколько раз было выбрано действие <tex>a</tex><br />
<br />
* <tex>Q_a = 0</tex< <tex>\forall a \in \{1 \ldots N\}</tex> {{---}} текущая оценка математического ожидания награды для действия <tex>a</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
* Выбираем действие с максимальной оценкой математического ожидания:<br />
<br />
:<tex>a_t = argmax \limits_{a \in A} Q_a </tex><br />
<br />
* Выполняем действие <tex>a_t</tex> и получаем награду <tex>R(a_t)</tex><br />
<br />
* Обновляем оценку математического ожидания для действия <tex>a_t</tex>:<br />
<br />
:<tex>P_{a_t} = P_{a_t} + 1</tex><br />
<br />
:<tex>Q_{a_t} = Q_{a_t} + \frac{1}{P_{a_t}} (R(a_t) − Q_{a_t})</tex><br />
<br />
В чем проблема?<br />
<br />
Пусть у нас есть "двурукий" бандит. Первая ручка всегда выдаёт награду равную 1, вторая всегда выдаёт 2. Действуя согласно жадной стратегии мы дёрнем в начале первую ручку, так как в начале оценки математических ожиданий равны нулю, увеличим её оценку до <tex>Q_1 = 1</tex>. В дальнейшем всегда будем выбирать первую ручку, а значит на каждом шаге будем получать на 1 меньше, чем могли бы.<br />
<br />
В данном случае достаточно попробовать в начале каждую из ручек вместо того, чтобы фокусироваться только на одной.<br />
Но если награда случайная величина, то единичной попытки будет не достаточно. Поэтому модифицируем жадную стратегию следующим образом:<br />
<br />
=== <tex>\epsilon</tex>-жадная (<tex>\epsilon</tex>-greedy) стратегия ===<br />
<br />
[[File:Eps-greedy.png|thumb|313px|Пример. Награда для стратегии с различными <tex>\epsilon</tex>]]<br />
<br />
Введем параметр <tex>\epsilon \in (0,1)</tex><br />
<br />
На каждом шаге <tex>t</tex><br />
<br />
* Получим значение <tex>\alpha</tex> {{---}} случайной величины равномерно распределенной на отрезке <tex>(0, 1)</tex><br />
* Если <tex>\alpha \in (0, \epsilon)</tex>, то выберем действие <tex>a_t \in A</tex> случайно и равновероятно, иначе как в жадной стратегии выбирем действие с максимальной оценкой математического ожидания:<br />
* Обновляем оценки так же как в жадной стратегии<br />
<br />
Если <tex>\epsilon = 0</tex>, то это обычная жадная стратегия. Однако если <tex>\epsilon > 0</tex>, то в отличии от жадной стратегии на каждом шаге с вероятностью <tex>\epsilon</tex> присходит "исследование" случайных действий.<br />
<br />
== Стратегия Softmax == <br />
<br />
Основная идея алгоритма ''softmax'' {{---}} уменьшение потерь при исследовании за счёт более редкого выбора действий, которые небольшую награду в прошлом. Чтобы этого добиться для каждого действия вычисляется весовой коэффициент на базе которого происходит выбор действия. Чем больше <tex>Q_t(a)</tex>, тем больше вероятность выбора <tex>a</tex>:<br />
<br />
<tex>\pi_{t+1}(a) = \frac{exp(Q_t(a) / \tau)}{\sum\limits_{b \in A} {exp(Q_t(b) / \tau)}}</tex><br />
<br />
<tex>\tau \in (0, \infty)</tex> {{---}} параметр, с помощью которого можно настраивать поведение алгоритма.<br />
<br />
При <tex>\tau \rightarrow \infty</tex> стратегия стремится к равномерной, то есть softmax будет меньше зависеть от значения выигрыша и выбирать действия более равномерно (режим исследования).<br />
<br />
При <tex>\tau \rightarrow 0</tex> стратегия стремится к жадной, то есть алгоритм будет больше ориентироваться на известный средний выигрыш действий (режим эксплуатации).<br />
<br />
Экспонента используется для того, чтобы данный вес был ненулевым даже у действий, награда от которых пока нулевая.<br />
<br />
Эвристика: параметр <tex>\tau</tex> имеет смысл уменьшать со временем.<br />
<br />
== Метод UCB (upper confidence bound) == <br />
<br />
Предыдущие алгоритмы при принятии решения используют данные о среднем выигрыше. Проблема в том, что если действие даёт награду с какой-то вероятностью, то данные от наблюдений получаются шумные и мы можем неправильно определять самое выгодное действие.<br />
<br />
Алгоритм верхнего доверительного интервала (''upper confidence bound'' или UCB) {{---}} семейство алгоритмов, которые пытаются решить эту проблему, используя при выборе данные не только о среднем выигрыше, но и о том, насколько можно доверять значениям выигрыша.<br />
<br />
Также как ''softmax'' в UCB при выборе действия используется весовой коэффициент, который представляет собой верхнюю границу доверительного интервала (upper confidence bound) значения выигрыша:<br />
<br />
<tex>\pi_{t+1}(a) = Q_t(a) + b_a</tex><br />
<br />
<tex>b_a = \sqrt{\frac{2 \ln{\sum_a P_a}}{P_a}} </tex> {{---}} бонусное значение, которые показывает, насколько недоисследовано действие по сравнению с остальными.<br />
<br />
Доказательство [http://banditalgs.com/2016/09/18/the-upper-confidence-bound-algorithm здесь]<br />
<br />
В отличие от предыдущих алгоритмов UCB не использует в своей работе ни случайные числа для выбора действия, ни параметры, которыми можно влиять на его работу. В начале работы алгоритма каждое из действий выбирается по одному разу (для того чтобы можно было вычислить размер бонуса для всех действий). После этого в каждый момент времени выбирается действие с максимальным значением весового коэффициента.<br />
<br />
Несмотря на это отсутствие случайности результаты работы этого алгоритма выглядят довольно шумно по сравнению с остальными. Это происходит из-за того, что данный алгоритм сравнительно часто выбирает недоисследованные действия.<br />
<br />
== Q-learning == <br />
<br />
На основе получаемого от среды вознаграждения агент формирует функцию полезности <tex>Q</tex>, что впоследствии дает ему возможность уже не случайно выбирать стратегию поведения, а учитывать опыт предыдущего взаимодействия со средой. Одно из преимуществ <tex>Q</tex>-обучения {{---}} то, что оно в состоянии сравнить ожидаемую полезность доступных действий, не формируя модели окружающей среды. Применяется для ситуаций, которые можно представить в виде МППР.<br />
<br />
Таким образом, алгоритм это функция качества от состояния и действия:<br />
<br />
:<tex>Q: S \times A \to \mathbb{R}</tex><br />
<br />
Перед обучением <tex>Q</tex> инициализируется случайными значениями. После этого в каждый момент времени <tex>t</tex> агент выбирает действие <tex>a_t</tex>, получает награду <tex>r_t</tex>, переходит в новое состояние <tex>s_{t+1}</tex>, которое может зависеть от предыдущего состояния <tex>s_t</tex> и выбранного действия, и обновляет функцию <tex>Q</tex>. Обновление функции использует взвешенное среднее между старым и новым значениями:<br />
<br />
:<tex>Q^{new}(s_{t},a_{t}) \leftarrow (1-\alpha) \cdot \underbrace{Q(s_{t},a_{t})}_{\text{old value}} + \underbrace{\alpha}_{\text{learning rate}} \cdot \overbrace{\bigg( \underbrace{r_{t}}_{\text{reward}} + \underbrace{\gamma}_{\text{discount factor}} \cdot \underbrace{\max_{a}Q(s_{t+1}, a)}_{\text{estimate of optimal future value}} \bigg) }^{\text{learned value}} </tex>,<br />
<br />
где ''<tex>r_{t}</tex>'' это награда, полученная при переходе из состояния <tex>s_{t}</tex> в состояние <tex>s_{t+1}</tex>, и <tex>\alpha</tex> это скорость обучения (<tex>0 < \alpha \le 1</tex>).<br />
<br />
Алгоритм заканчивается, когда агент переходит в терминальное состояние <tex>s_{t+1}</tex>.<br />
<br />
=== Aлгоритм Q-learning ===<br />
<br />
[[File:Q-Learning.png|thumb|313px|Процесс Q-обучения]]<br />
<br />
* <tex>S</tex> — множество состояний<br />
* <tex>A</tex> — множество действий<br />
* <tex>R = S \times A \rightarrow \mathbb{R}</tex> — функция награды<br />
* <tex>T = S \times A \rightarrow S</tex> — функция перехода<br />
* <tex>\alpha \in [0, 1]</tex> — learning rate (обычно 0.1), чем он выше, тем сильнее агент доверяет новой информации<br />
* <tex>\gamma \in [0, 1]</tex> — discounting factor, чем он меньше, тем меньше агент задумывается о выгоде от будущих своих действий<br />
<br />
'''fun''' Q-learning(<tex>S, A, R, T, \alpha, \gamma</tex>):<br />
'''for''' <tex> s \in S</tex>:<br />
'''for''' <tex> a \in A</tex>:<br />
Q(s, a) = rand()<br />
'''while''' Q не сошелся:<br />
s = <tex> \forall s \in S</tex><br />
'''while''' s не конечное состояние:<br />
<tex>\pi(s) = argmax_{a}{Q(s, a)}</tex><br />
a = <tex>\pi(s)</tex><br />
r = R(s, a)<br />
s' = T(s, a)<br />
<tex>Q(s', a) = (1 - \alpha) Q(s', a) + \alpha (r + \gamma * \max\limits_{a'}{Q(s', a')})</tex><br />
s = s'<br />
return Q<br />
<br />
<br />
== Ссылки ==<br />
<br />
*[http://en.wikipedia.org/wiki/Reinforcement_learning Wikipedia: Reinforcement learning]<br />
*[http://www.machinelearning.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BF%D0%BE%D0%B4%D0%BA%D1%80%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC Обучение с подкреплением]<br />
* [https://en.wikipedia.org/wiki/Multi-armed_bandit Многорукий бандит]<br />
* [https://vbystricky.github.io/2017/01/rl_multi_arms_bandits.html Задача о многоруком бандите]<br />
* [http://www.machinelearning.ru/wiki/images/archive/3/35/20121120213057%21Voron-ML-RL-slides.pdf Обучение с подкреплением (Reinforcement Learning) К.В.Воронцов]<br />
* [https://pryazhnikov.com/ru/bandit-algorithms-for-website-optimization/ Обзор книги «Bandit Algorithms for Website Optimization»]<br />
* [https://en.wikipedia.org/wiki/Q-learning Q-learning]<br />
* [https://medium.freecodecamp.org/an-introduction-to-q-learning-reinforcement-learning-14ac0b4493cc An introduction to Q-Learning: reinforcement learning]</div>Dariyakovleva