Викиконспекты - Вклад участника [ru]

Мета-обучение

2019-01-25T23:16:30Z

5.18.218.179: Замена еще одного -

<b>Мета-обучение</b> {{---}} подход, позволяющий определять оптимальный алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свести задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-фичами. Мета-фича описывает свойство задачи {{---}} например, разрежен ли датасет или нет.

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

Такими задачами являются:
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек, смог определить, есть ли на новой картинке кошка
* Игровой бот, способный быстро обучиться новой игре
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности

Ограничения {{---}} 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>

<h2>Simple view</h2>

Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.
Оптимальные параметры модели:

\begin{aligned}
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})]
\end{aligned}

Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.

Few-shot классификатор конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,
train set $S$ и test set $B$. Часто принимается k-shot N-class задача - train set содержит $k$ размеченных примеров для каждого из $N$ классов.
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$ и каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:

\begin{aligned}
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})] &\\
\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.}}
\end{aligned}

В few-shot классификации цель {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения, сделаем следующее:
# возьмем подмножество меток, $L\subset\mathcal{L}$
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:

\begin{aligned}
L, y \in L, \forall (x, y) \in S^L, B^L
\end{aligned}

# Множество $S^L$ подается на вход модели.
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобы она могла обобщиться до других датасетов.
Красным выделен дифф между обучением с учителем и мета-обучением.

\begin{aligned}
\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}{]}
\end{aligned}

Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того, чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.

<h2>Основанные на оптимизации</h2>

Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее, оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов, и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.

<h3>LSTM-meta-learner</h3>
Оптимизационный алгоритм может быть явно смоделирован. Ravi & Larochelle (2017) это и сделали и назвали его "meta-learner". Цель meta-learner'а - эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.

Пусть модель ученика будет $M_θ$, параметризованной $θ$, и meta-learner как $R_Θ$ с параметром $θ$, и функция потерь $\mathcal{L}$.

Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):

\begin{aligned}
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t
\end{aligned}

Обновление памяти ячейки LSTM выглядит так:

\begin{aligned}
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
\end{aligned}

$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ - не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin{aligned}
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{; как сильно мы забываем старые значения параметров.}}\\
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.}}\\
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t &\\
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t &\\
\end{aligned}

я ничего не понял..

<h3>REPTILE</h3>

Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентный спуск и оба не чувствительны к модели.

# сэмплируем задачу
# тренируемся на ней несколькими шагами градиентного спуска
# сдвигаем веса модели к новым параметрам.

$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.

<font color=green>// Algorithm REPTILE, batched version</font>
Initialize $\theta$
'''for''' $iteration = 1, 2,...$ '''do'''
Sample tasks $\tau_1, \tau_2, ..., \tau_n$
'''for''' $i = 1, 2, ..., n$ '''do'''
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$
'''end for'''
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$
'''end for'''

<h2>Определение множества конфигураций</h2>
Предшествующие вычисления могут быть также использованы для изучения пространства более успешных конфигураций \theta\star. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных рессурсах.

Альтернативный подход сперва узнать оптимальные гиперпараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей для этого алгоритма на большом числе задач. После того, как уже проверены многие варианты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной.Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.

Если мы хотим предоставить рекомендации для конкретной задачи $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}$ for $t_{new}$.
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_new$ и перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.

<h3>Relative landmarks</h3>
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.

<h3>Суррогатные модели</h3>
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.

Так же можно обучать суррогатные модели на Гауссовских процессах (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}$.

Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ получается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).

<h3>Обучение на свойствах задачи (learning on task properties)</h3>
Каждая задача $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}$.

$L: \Theta \times M \rightarrow \textbf{P}$

В таблице представлен обзор наиболее используемых мета-фичей.

{| class="wikitable"
|+ Meta-feature
|-
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''
|-
| colspan="4" align="center" | '''simple'''
|-
| Nr instances || $n$ || Speed, Scalability \citep{Michie1994} || $p/n$, $log(n)$, log(n/p)
|-
| Nr features || $p$ || Curse of dimensionality \citep{Michie1994} || $log(p)$, % categorical
|-
| Nr classes || $c$ || Complexity, imbalance \citep{Michie1994} || ratio min/maj class
|-
| Nr missing values || $m$ || Imputation effects \citep{kalousis02} || % missing
|-
| Nr outliers || $o$ || Data noisiness \citep{Rousseeuw2011} || $o/n$
|-
| colspan="4" align="center" | '''statistical'''
|-
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$\rho_{XY}$
|-
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$cov_{XY}$
|-
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence \citep{Kalousis2001a} || min,max,$\mu$,$\sigma$,$\tau_{XY}$
|-
| Sparsity || sparsity(X) || Degree of discreteness \citep{Salama2013} || min,max,$\mu$,$\sigma$
|-
| Gravity || gravity(X) || Inter-class dispersion \citep{Ali2006} ||
|-
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy \citep{kalousis02} || $p_{val_{XY}}$\citep{soares+04}
|-
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target \citep{soares+04} ||
|-
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC \citep{Michie1994} || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{Michie1994}
|-
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis
|-
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality \citep{bardenet2013collaborative} ||
|-
| Class probability || $P(\texttt{C})$ || Class distribution \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| colspan="4" align="center" | '''informational-theoretic'''
|-
| Class entropy || $H(\texttt{C})$ || Class imbalance \citep{Michie1994} ||
|-
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness \citep{Castiello2005} || min,max,$\mu$,$\sigma$
|-
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || Feature importance \citep{Agresti:2002p7509} || min,max,$\mu$,$\sigma$
|-
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality \citep{Michie1994} ||
|-
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data \citep{Michie1994} ||
|-
| colspan="4" align="center" | '''complexity'''
|-
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ \citep{Ho:2002} || See \citet{}{Ho:2002}
|-
| Volume of overlap || || Class distribution overlap \citep{Ho:2002} || See \citet{Ho:2002}
|-
| Concept variation || || Task complexity \citep{Vilalta:2002p5805} || See \citet{Vilalta:1999p5745}
|-
| Data consistency || || Data quality \citep{Kopf:2002p5864} || See \citet{Kopf:2002p5864}
|-
| colspan="4" align="center" | '''model-based'''
|-
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity \citep{Peng:2002p705} || Tree depth
|-
| Branch length || || Concept complexity \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity \citep{Filchenkov2015} || min,max,$\mu$,$\sigma$
|-
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability \citep{Bensusan2000} || min,max,$\mu$,$\sigma$
|-
| Information gain || || Feature importance \citep{Bensusan2000} || min,max,$\mu$,$\sigma$, gini
|-
| colspan="4" align="center" | '''landmarks'''
|-
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity \citep{Pfahringer:2000p553} || See \citet{Pfahringer:2000p553}
|-
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability \citep{Pfahringer:2000p553} || Stump,RandomTree
|-
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability \citep{Pfahringer:2000p553} || Lin.Disciminant
|-
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence \citep{Pfahringer:2000p553} || See \citet{Ler:2005p1680}
|-
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance \citep{Furnkranz:2001p1278} ||
|-
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance \citep{Soares:2001p708} ||
|-
|}

Непрерывные фичи $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+})$.

Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей, и должны быть агрегированы через min,max,$\mu$,$\sigma$,quartiles или гистограммами [kalousis]

Во время вычисления похожести задач важно нормализовать все мета-фичи [bardnet], использовать feature selection [todorovski] или использовать dimensionality reduction (PCA, например).

== Примечания ==
<references/>

* https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem
* https://arxiv.org/pdf/1810.03548.pdf
* https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf
* https://openreview.net/pdf?id=rJY0-Kcll
* https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf
* Alexandros Kalousis and Melanie Hilario. Model selection via meta-learning: a comparative study. Intl Journ. on Artificial Intelligence Tools, 10(4):525–554, 2001.
* 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
* L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP. Lecture Notes in Computer Science, 1704:98–106, 1999.

[[Категория: Машинное обучение]]

Мета-обучение

2019-01-25T23:13:56Z

5.18.218.179: Добавление категории

<b>Мета-обучение</b> {{---}} подход, позволяющий определять оптимальный алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свести задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-фичами. Мета-фича описывает свойство задачи {{---}} например, разрежен ли датасет или нет.

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

Такими задачами являются:
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек, смог определить, есть ли на новой картинке кошка
* Игровой бот, способный быстро обучиться новой игре
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности

Ограничения
- 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>

<h2>Simple view</h2>

Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.
Оптимальные параметры модели:

\begin{aligned}
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})]
\end{aligned}

Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.

Few-shot классификатор конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,
train set $S$ и test set $B$. Часто принимается k-shot N-class задача - train set содержит $k$ размеченных примеров для каждого из $N$ классов.
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$ и каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:

\begin{aligned}
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})] &\\
\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.}}
\end{aligned}

В few-shot классификации цель {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения, сделаем следующее:
# возьмем подмножество меток, $L\subset\mathcal{L}$
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:

\begin{aligned}
L, y \in L, \forall (x, y) \in S^L, B^L
\end{aligned}

# Множество $S^L$ подается на вход модели.
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобы она могла обобщиться до других датасетов.
Красным выделен дифф между обучением с учителем и мета-обучением.

\begin{aligned}
\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}{]}
\end{aligned}

Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того, чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.

<h2>Основанные на оптимизации</h2>

Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее, оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов, и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.

<h3>LSTM-meta-learner</h3>
Оптимизационный алгоритм может быть явно смоделирован. Ravi & Larochelle (2017) это и сделали и назвали его "meta-learner". Цель meta-learner'а - эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.

Пусть модель ученика будет $M_θ$, параметризованной $θ$, и meta-learner как $R_Θ$ с параметром $θ$, и функция потерь $\mathcal{L}$.

Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):

\begin{aligned}
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t
\end{aligned}

Обновление памяти ячейки LSTM выглядит так:

\begin{aligned}
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
\end{aligned}

$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ - не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin{aligned}
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{; как сильно мы забываем старые значения параметров.}}\\
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.}}\\
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t &\\
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t &\\
\end{aligned}

я ничего не понял..

<h3>REPTILE</h3>

Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентный спуск и оба не чувствительны к модели.

# сэмплируем задачу
# тренируемся на ней несколькими шагами градиентного спуска
# сдвигаем веса модели к новым параметрам.

$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.

<font color=green>// Algorithm REPTILE, batched version</font>
Initialize $\theta$
'''for''' $iteration = 1, 2,...$ '''do'''
Sample tasks $\tau_1, \tau_2, ..., \tau_n$
'''for''' $i = 1, 2, ..., n$ '''do'''
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$
'''end for'''
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$
'''end for'''

<h2>Определение множества конфигураций</h2>
Предшествующие вычисления могут быть также использованы для изучения пространства более успешных конфигураций \theta\star. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных рессурсах.

Альтернативный подход сперва узнать оптимальные гиперпараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей для этого алгоритма на большом числе задач. После того, как уже проверены многие варианты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной.Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.

Если мы хотим предоставить рекомендации для конкретной задачи $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}$ for $t_{new}$.
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_new$ и перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.

<h3>Relative landmarks</h3>
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.

<h3>Суррогатные модели</h3>
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.

Так же можно обучать суррогатные модели на Гауссовских процессах (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}$.

Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ получается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).

<h3>Обучение на свойствах задачи (learning on task properties)</h3>
Каждая задача $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}$.

$L: \Theta \times M \rightarrow \textbf{P}$

В таблице представлен обзор наиболее используемых мета-фичей.

{| class="wikitable"
|+ Meta-feature
|-
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''
|-
| colspan="4" align="center" | '''simple'''
|-
| Nr instances || $n$ || Speed, Scalability \citep{Michie1994} || $p/n$, $log(n)$, log(n/p)
|-
| Nr features || $p$ || Curse of dimensionality \citep{Michie1994} || $log(p)$, % categorical
|-
| Nr classes || $c$ || Complexity, imbalance \citep{Michie1994} || ratio min/maj class
|-
| Nr missing values || $m$ || Imputation effects \citep{kalousis02} || % missing
|-
| Nr outliers || $o$ || Data noisiness \citep{Rousseeuw2011} || $o/n$
|-
| colspan="4" align="center" | '''statistical'''
|-
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$\rho_{XY}$
|-
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$cov_{XY}$
|-
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence \citep{Kalousis2001a} || min,max,$\mu$,$\sigma$,$\tau_{XY}$
|-
| Sparsity || sparsity(X) || Degree of discreteness \citep{Salama2013} || min,max,$\mu$,$\sigma$
|-
| Gravity || gravity(X) || Inter-class dispersion \citep{Ali2006} ||
|-
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy \citep{kalousis02} || $p_{val_{XY}}$\citep{soares+04}
|-
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target \citep{soares+04} ||
|-
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC \citep{Michie1994} || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{Michie1994}
|-
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis
|-
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality \citep{bardenet2013collaborative} ||
|-
| Class probability || $P(\texttt{C})$ || Class distribution \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| colspan="4" align="center" | '''informational-theoretic'''
|-
| Class entropy || $H(\texttt{C})$ || Class imbalance \citep{Michie1994} ||
|-
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness \citep{Castiello2005} || min,max,$\mu$,$\sigma$
|-
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || Feature importance \citep{Agresti:2002p7509} || min,max,$\mu$,$\sigma$
|-
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality \citep{Michie1994} ||
|-
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data \citep{Michie1994} ||
|-
| colspan="4" align="center" | '''complexity'''
|-
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ \citep{Ho:2002} || See \citet{}{Ho:2002}
|-
| Volume of overlap || || Class distribution overlap \citep{Ho:2002} || See \citet{Ho:2002}
|-
| Concept variation || || Task complexity \citep{Vilalta:2002p5805} || See \citet{Vilalta:1999p5745}
|-
| Data consistency || || Data quality \citep{Kopf:2002p5864} || See \citet{Kopf:2002p5864}
|-
| colspan="4" align="center" | '''model-based'''
|-
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity \citep{Peng:2002p705} || Tree depth
|-
| Branch length || || Concept complexity \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity \citep{Filchenkov2015} || min,max,$\mu$,$\sigma$
|-
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability \citep{Bensusan2000} || min,max,$\mu$,$\sigma$
|-
| Information gain || || Feature importance \citep{Bensusan2000} || min,max,$\mu$,$\sigma$, gini
|-
| colspan="4" align="center" | '''landmarks'''
|-
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity \citep{Pfahringer:2000p553} || See \citet{Pfahringer:2000p553}
|-
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability \citep{Pfahringer:2000p553} || Stump,RandomTree
|-
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability \citep{Pfahringer:2000p553} || Lin.Disciminant
|-
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence \citep{Pfahringer:2000p553} || See \citet{Ler:2005p1680}
|-
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance \citep{Furnkranz:2001p1278} ||
|-
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance \citep{Soares:2001p708} ||
|-
|}

Непрерывные фичи $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+})$.

Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей, и должны быть агрегированы через min,max,$\mu$,$\sigma$,quartiles или гистограммами [kalousis]

Во время вычисления похожести задач важно нормализовать все мета-фичи [bardnet], использовать feature selection [todorovski] или использовать dimensionality reduction (PCA, например).

== Примечания ==
<references/>

* https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem
* https://arxiv.org/pdf/1810.03548.pdf
* https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf
* https://openreview.net/pdf?id=rJY0-Kcll
* https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf
* Alexandros Kalousis and Melanie Hilario. Model selection via meta-learning: a comparative study. Intl Journ. on Artificial Intelligence Tools, 10(4):525–554, 2001.
* 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
* L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP. Lecture Notes in Computer Science, 1704:98–106, 1999.

[[Категория: Машинное обучение]]

Мета-обучение

2019-01-25T23:13:18Z

5.18.218.179: Замена текстовых ссылок на сноски

<b>Мета-обучение</b> {{---}} подход, позволяющий определять оптимальный алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свести задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-фичами. Мета-фича описывает свойство задачи {{---}} например, разрежен ли датасет или нет.

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

Такими задачами являются:
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек, смог определить, есть ли на новой картинке кошка
* Игровой бот, способный быстро обучиться новой игре
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности

Ограничения
- 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>

<h2>Simple view</h2>

Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.
Оптимальные параметры модели:

\begin{aligned}
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})]
\end{aligned}

Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.

Few-shot классификатор конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,
train set $S$ и test set $B$. Часто принимается k-shot N-class задача - train set содержит $k$ размеченных примеров для каждого из $N$ классов.
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$ и каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:

\begin{aligned}
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})] &\\
\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.}}
\end{aligned}

В few-shot классификации цель {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения, сделаем следующее:
# возьмем подмножество меток, $L\subset\mathcal{L}$
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:

\begin{aligned}
L, y \in L, \forall (x, y) \in S^L, B^L
\end{aligned}

# Множество $S^L$ подается на вход модели.
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобы она могла обобщиться до других датасетов.
Красным выделен дифф между обучением с учителем и мета-обучением.

\begin{aligned}
\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}{]}
\end{aligned}

Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того, чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.

<h2>Основанные на оптимизации</h2>

Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее, оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов, и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.

<h3>LSTM-meta-learner</h3>
Оптимизационный алгоритм может быть явно смоделирован. Ravi & Larochelle (2017) это и сделали и назвали его "meta-learner". Цель meta-learner'а - эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.

Пусть модель ученика будет $M_θ$, параметризованной $θ$, и meta-learner как $R_Θ$ с параметром $θ$, и функция потерь $\mathcal{L}$.

Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):

\begin{aligned}
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t
\end{aligned}

Обновление памяти ячейки LSTM выглядит так:

\begin{aligned}
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
\end{aligned}

$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ - не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin{aligned}
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{; как сильно мы забываем старые значения параметров.}}\\
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.}}\\
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t &\\
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t &\\
\end{aligned}

я ничего не понял..

<h3>REPTILE</h3>

Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентный спуск и оба не чувствительны к модели.

# сэмплируем задачу
# тренируемся на ней несколькими шагами градиентного спуска
# сдвигаем веса модели к новым параметрам.

$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.

<font color=green>// Algorithm REPTILE, batched version</font>
Initialize $\theta$
'''for''' $iteration = 1, 2,...$ '''do'''
Sample tasks $\tau_1, \tau_2, ..., \tau_n$
'''for''' $i = 1, 2, ..., n$ '''do'''
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$
'''end for'''
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$
'''end for'''

<h2>Определение множества конфигураций</h2>
Предшествующие вычисления могут быть также использованы для изучения пространства более успешных конфигураций \theta\star. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных рессурсах.

Альтернативный подход сперва узнать оптимальные гиперпараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей для этого алгоритма на большом числе задач. После того, как уже проверены многие варианты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной.Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.

Если мы хотим предоставить рекомендации для конкретной задачи $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}$ for $t_{new}$.
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_new$ и перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.

<h3>Relative landmarks</h3>
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.

<h3>Суррогатные модели</h3>
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.

Так же можно обучать суррогатные модели на Гауссовских процессах (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}$.

Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ получается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).

<h3>Обучение на свойствах задачи (learning on task properties)</h3>
Каждая задача $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}$.

$L: \Theta \times M \rightarrow \textbf{P}$

В таблице представлен обзор наиболее используемых мета-фичей.

{| class="wikitable"
|+ Meta-feature
|-
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''
|-
| colspan="4" align="center" | '''simple'''
|-
| Nr instances || $n$ || Speed, Scalability \citep{Michie1994} || $p/n$, $log(n)$, log(n/p)
|-
| Nr features || $p$ || Curse of dimensionality \citep{Michie1994} || $log(p)$, % categorical
|-
| Nr classes || $c$ || Complexity, imbalance \citep{Michie1994} || ratio min/maj class
|-
| Nr missing values || $m$ || Imputation effects \citep{kalousis02} || % missing
|-
| Nr outliers || $o$ || Data noisiness \citep{Rousseeuw2011} || $o/n$
|-
| colspan="4" align="center" | '''statistical'''
|-
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$\rho_{XY}$
|-
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$cov_{XY}$
|-
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence \citep{Kalousis2001a} || min,max,$\mu$,$\sigma$,$\tau_{XY}$
|-
| Sparsity || sparsity(X) || Degree of discreteness \citep{Salama2013} || min,max,$\mu$,$\sigma$
|-
| Gravity || gravity(X) || Inter-class dispersion \citep{Ali2006} ||
|-
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy \citep{kalousis02} || $p_{val_{XY}}$\citep{soares+04}
|-
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target \citep{soares+04} ||
|-
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC \citep{Michie1994} || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{Michie1994}
|-
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis
|-
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality \citep{bardenet2013collaborative} ||
|-
| Class probability || $P(\texttt{C})$ || Class distribution \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| colspan="4" align="center" | '''informational-theoretic'''
|-
| Class entropy || $H(\texttt{C})$ || Class imbalance \citep{Michie1994} ||
|-
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness \citep{Castiello2005} || min,max,$\mu$,$\sigma$
|-
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || Feature importance \citep{Agresti:2002p7509} || min,max,$\mu$,$\sigma$
|-
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality \citep{Michie1994} ||
|-
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data \citep{Michie1994} ||
|-
| colspan="4" align="center" | '''complexity'''
|-
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ \citep{Ho:2002} || See \citet{}{Ho:2002}
|-
| Volume of overlap || || Class distribution overlap \citep{Ho:2002} || See \citet{Ho:2002}
|-
| Concept variation || || Task complexity \citep{Vilalta:2002p5805} || See \citet{Vilalta:1999p5745}
|-
| Data consistency || || Data quality \citep{Kopf:2002p5864} || See \citet{Kopf:2002p5864}
|-
| colspan="4" align="center" | '''model-based'''
|-
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity \citep{Peng:2002p705} || Tree depth
|-
| Branch length || || Concept complexity \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity \citep{Filchenkov2015} || min,max,$\mu$,$\sigma$
|-
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability \citep{Bensusan2000} || min,max,$\mu$,$\sigma$
|-
| Information gain || || Feature importance \citep{Bensusan2000} || min,max,$\mu$,$\sigma$, gini
|-
| colspan="4" align="center" | '''landmarks'''
|-
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity \citep{Pfahringer:2000p553} || See \citet{Pfahringer:2000p553}
|-
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability \citep{Pfahringer:2000p553} || Stump,RandomTree
|-
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability \citep{Pfahringer:2000p553} || Lin.Disciminant
|-
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence \citep{Pfahringer:2000p553} || See \citet{Ler:2005p1680}
|-
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance \citep{Furnkranz:2001p1278} ||
|-
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance \citep{Soares:2001p708} ||
|-
|}

Непрерывные фичи $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+})$.

Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей, и должны быть агрегированы через min,max,$\mu$,$\sigma$,quartiles или гистограммами [kalousis]

Во время вычисления похожести задач важно нормализовать все мета-фичи [bardnet], использовать feature selection [todorovski] или использовать dimensionality reduction (PCA, например).

== Примечания ==
<references/>

* https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem
* https://arxiv.org/pdf/1810.03548.pdf
* https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf
* https://openreview.net/pdf?id=rJY0-Kcll
* https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf
* Alexandros Kalousis and Melanie Hilario. Model selection via meta-learning: a comparative study. Intl Journ. on Artificial Intelligence Tools, 10(4):525–554, 2001.
* 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
* L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP. Lecture Notes in Computer Science, 1704:98–106, 1999.

Мета-обучение

2019-01-25T23:08:16Z

5.18.218.179: Исправление опечаток

<b>Мета-обучение</b> {{---}} подход, позволяющий определять оптимальный алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свести задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-фичами. Мета-фича описывает свойство задачи {{---}} например, разрежен ли датасет или нет.

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

Такими задачами являются:
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек, смог определить, есть ли на новой картинке кошка
* Игровой бот, способный быстро обучиться новой игре
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности

Ограничения
- No free lunch teorem [Wolpert and Macready, 1996; Giraud-Carrier and Provost, 2005]

<h2>Simple view</h2>

Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.
Оптимальные параметры модели:

\begin{aligned}
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})]
\end{aligned}

Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.

Few-shot классификатор конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,
train set $S$ и test set $B$. Часто принимается k-shot N-class задача - train set содержит $k$ размеченных примеров для каждого из $N$ классов.
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$ и каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:

\begin{aligned}
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})] &\\
\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.}}
\end{aligned}

В few-shot классификации цель {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения, сделаем следующее:
# возьмем подмножество меток, $L\subset\mathcal{L}$
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:

\begin{aligned}
L, y \in L, \forall (x, y) \in S^L, B^L
\end{aligned}

# Множество $S^L$ подается на вход модели.
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобы она могла обобщиться до других датасетов.
Красным выделен дифф между обучением с учителем и мета-обучением.

\begin{aligned}
\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}{]}
\end{aligned}

Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того, чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.

<h2>Основанные на оптимизации</h2>

Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее, оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов, и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.

<h3>LSTM-meta-learner</h3>
Оптимизационный алгоритм может быть явно смоделирован. Ravi & Larochelle (2017) это и сделали и назвали его "meta-learner". Цель meta-learner'а - эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.

Пусть модель ученика будет $M_θ$, параметризованной $θ$, и meta-learner как $R_Θ$ с параметром $θ$, и функция потерь $\mathcal{L}$.

Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):

\begin{aligned}
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t
\end{aligned}

Обновление памяти ячейки LSTM выглядит так:

\begin{aligned}
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
\end{aligned}

$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ - не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin{aligned}
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{; как сильно мы забываем старые значения параметров.}}\\
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.}}\\
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t &\\
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t &\\
\end{aligned}

я ничего не понял..

<h3>REPTILE</h3>

Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентный спуск и оба не чувствительны к модели.

# сэмплируем задачу
# тренируемся на ней несколькими шагами градиентного спуска
# сдвигаем веса модели к новым параметрам.

$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.

<font color=green>// Algorithm REPTILE, batched version</font>
Initialize $\theta$
'''for''' $iteration = 1, 2,...$ '''do'''
Sample tasks $\tau_1, \tau_2, ..., \tau_n$
'''for''' $i = 1, 2, ..., n$ '''do'''
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$
'''end for'''
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$
'''end for'''

<h2>Определение множества конфигураций</h2>
Предшествующие вычисления могут быть также использованы для изучения пространства более успешных конфигураций \theta\star. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных рессурсах.

Альтернативный подход сперва узнать оптимальные гиперпараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей для этого алгоритма на большом числе задач. После того, как уже проверены многие варианты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной.Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.

Если мы хотим предоставить рекомендации для конкретной задачи $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}$ for $t_{new}$.
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_new$ и перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.

<h3>Relative landmarks</h3>
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.

<h3>Суррогатные модели</h3>
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.

Так же можно обучать суррогатные модели на Гауссовских процессах (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}$.

Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ получается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).

<h3>Обучение на свойствах задачи (learning on task properties)</h3>
Каждая задача $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}$.

$L: \Theta \times M \rightarrow \textbf{P}$

В таблице представлен обзор наиболее используемых мета-фичей.

{| class="wikitable"
|+ Meta-feature
|-
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''
|-
| colspan="4" align="center" | '''simple'''
|-
| Nr instances || $n$ || Speed, Scalability \citep{Michie1994} || $p/n$, $log(n)$, log(n/p)
|-
| Nr features || $p$ || Curse of dimensionality \citep{Michie1994} || $log(p)$, % categorical
|-
| Nr classes || $c$ || Complexity, imbalance \citep{Michie1994} || ratio min/maj class
|-
| Nr missing values || $m$ || Imputation effects \citep{kalousis02} || % missing
|-
| Nr outliers || $o$ || Data noisiness \citep{Rousseeuw2011} || $o/n$
|-
| colspan="4" align="center" | '''statistical'''
|-
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$\rho_{XY}$
|-
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$cov_{XY}$
|-
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence \citep{Kalousis2001a} || min,max,$\mu$,$\sigma$,$\tau_{XY}$
|-
| Sparsity || sparsity(X) || Degree of discreteness \citep{Salama2013} || min,max,$\mu$,$\sigma$
|-
| Gravity || gravity(X) || Inter-class dispersion \citep{Ali2006} ||
|-
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy \citep{kalousis02} || $p_{val_{XY}}$\citep{soares+04}
|-
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target \citep{soares+04} ||
|-
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC \citep{Michie1994} || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{Michie1994}
|-
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis
|-
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality \citep{bardenet2013collaborative} ||
|-
| Class probability || $P(\texttt{C})$ || Class distribution \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| colspan="4" align="center" | '''informational-theoretic'''
|-
| Class entropy || $H(\texttt{C})$ || Class imbalance \citep{Michie1994} ||
|-
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness \citep{Castiello2005} || min,max,$\mu$,$\sigma$
|-
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || Feature importance \citep{Agresti:2002p7509} || min,max,$\mu$,$\sigma$
|-
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality \citep{Michie1994} ||
|-
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data \citep{Michie1994} ||
|-
| colspan="4" align="center" | '''complexity'''
|-
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ \citep{Ho:2002} || See \citet{}{Ho:2002}
|-
| Volume of overlap || || Class distribution overlap \citep{Ho:2002} || See \citet{Ho:2002}
|-
| Concept variation || || Task complexity \citep{Vilalta:2002p5805} || See \citet{Vilalta:1999p5745}
|-
| Data consistency || || Data quality \citep{Kopf:2002p5864} || See \citet{Kopf:2002p5864}
|-
| colspan="4" align="center" | '''model-based'''
|-
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity \citep{Peng:2002p705} || Tree depth
|-
| Branch length || || Concept complexity \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity \citep{Filchenkov2015} || min,max,$\mu$,$\sigma$
|-
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability \citep{Bensusan2000} || min,max,$\mu$,$\sigma$
|-
| Information gain || || Feature importance \citep{Bensusan2000} || min,max,$\mu$,$\sigma$, gini
|-
| colspan="4" align="center" | '''landmarks'''
|-
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity \citep{Pfahringer:2000p553} || See \citet{Pfahringer:2000p553}
|-
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability \citep{Pfahringer:2000p553} || Stump,RandomTree
|-
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability \citep{Pfahringer:2000p553} || Lin.Disciminant
|-
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence \citep{Pfahringer:2000p553} || See \citet{Ler:2005p1680}
|-
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance \citep{Furnkranz:2001p1278} ||
|-
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance \citep{Soares:2001p708} ||
|-
|}

Непрерывные фичи $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+})$.

Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей, и должны быть агрегированы через min,max,$\mu$,$\sigma$,quartiles или гистограммами [kalousis]

Во время вычисления похожести задач важно нормализовать все мета-фичи [bardnet], использовать feature selection [todorovski] или использовать dimensionality reduction (PCA, например).

<h2>Примечания</h2>

https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem
https://arxiv.org/pdf/1810.03548.pdf
https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf
https://openreview.net/pdf?id=rJY0-Kcll
https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf
Alexandros Kalousis and Melanie Hilario. Model selection v
ia meta-learning: a comparative
study.
Intl Journ. on Artificial Intelligence Tools
, 10(4):525–554, 2001.
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
L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP.
Lecture Notes in Computer Science, 1704:98–106, 1999.

Мета-обучение

2019-01-25T23:06:01Z

5.18.218.179: Исправление опечатки

<b>Мета-обучение</b> {{---}} подход, повзоляющий определять оптимальный алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свести задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-фичами. Мета-фича описывает свойство задачи {{---}} напмример, разрежен ли датасет или нет.

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

Такими задачами являются:
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек, смог определить, есть ли на новой картинке кошка
* Игровой бот, способный быстро обучиться новой игре
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности

Ограничения
- No free lunch teorem [Wolpert and Macready, 1996; Giraud-Carrier and Provost, 2005]

<h2>Simple view</h2>

Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.
Оптимальные параметры модели:

\begin{aligned}
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})]
\end{aligned}

Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.

Few-shot классификатор конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,
train set $S$ и test set $B$. Часто принимается k-shot N-class задача - train set содержит $k$ размеченных примеров для каждого из $N$ классов.
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$ и каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:

\begin{aligned}
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})] &\\
\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.}}
\end{aligned}

В few-shot классификации цель {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения, сделаем следующее:
# возьмем подмножество меток, $L\subset\mathcal{L}$
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:

\begin{aligned}
L, y \in L, \forall (x, y) \in S^L, B^L
\end{aligned}

# Множество $S^L$ подается на вход модели.
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобыона могла обобщиться до других датасетов.
Красным выделен дифф между обучением с учителем и мета-обучением.

\begin{aligned}
\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}{]}
\end{aligned}

Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того, чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.

<h2>Основанные на оптимизации</h2>

Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее, оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов, и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.

<h3>LSTM-meta-learner</h3>
Оптимизационный алгоитм может быть явно смоделирован. Ravi & Larochelle (2017) это и сделали и назвали его "meta-learner". Цель meta-learner'а - эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.

Пусть модель ученика будет $M_θ$, параметризованной $θ$, и meta-learner как $R_Θ$ с параметром $θ$, и функция потерь $\mathcal{L}$.

Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):

\begin{aligned}
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t
\end{aligned}

Обновление памяти ячейки LSTM выглядит так:

\begin{aligned}
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
\end{aligned}

$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ - не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin{aligned}
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{; как сильно мы забываем старые значения параметров.}}\\
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.}}\\
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t &\\
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t &\\
\end{aligned}

я ничего не понял..

<h3>REPTILE</h3>

Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентый спуск и оба не чувствительны к модели.

# сэмплируем задачу
# тренируемся на ней несколькими шагами градиентного спуска
# сдвигаем веса модели к новым параметрам.

$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.

<font color=green>// Algorithm REPTILE, batched version</font>
Initialize $\theta$
'''for''' $iteration = 1, 2,...$ '''do'''
Sample tasks $\tau_1, \tau_2, ..., \tau_n$
'''for''' $i = 1, 2, ..., n$ '''do'''
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$
'''end for'''
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$
'''end for'''

<h2>Определение множества конфигураций</h2>
Предшествующие выисления могут быть также использованы для изучения пространства более успешных конфигураций \theta\star. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных рессурсах.

Альтернативный подход сперва узнать оптимальные гипермараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей для этого алгоритма на большом числе задач. После того, как уже проверены многие варинаты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной.Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.

Если мы хотим предоставить рекомендации для конкретной задачи $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}$ for $t_{new}$.
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_new$ и перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.

<h3>Relative landmarks</h3>
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.

<h3>Суррогатные модели</h3>
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.

Так же можно обучать суррогатные модли на Гауссовских процессах (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}$.

Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ поулчается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).

<h3>Обучение на свойствах задачи (learning on task properties)</h3>
Каждая задача $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}$.

$L: \Theta \times M \rightarrow \textbf{P}$

В таблице представлен обзор наиболее используемых мета-фичей.

{| class="wikitable"
|+ Meta-feature
|-
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''
|-
| colspan="4" align="center" | '''simple'''
|-
| Nr instances || $n$ || Speed, Scalability \citep{Michie1994} || $p/n$, $log(n)$, log(n/p)
|-
| Nr features || $p$ || Curse of dimensionality \citep{Michie1994} || $log(p)$, % categorical
|-
| Nr classes || $c$ || Complexity, imbalance \citep{Michie1994} || ratio min/maj class
|-
| Nr missing values || $m$ || Imputation effects \citep{kalousis02} || % missing
|-
| Nr outliers || $o$ || Data noisiness \citep{Rousseeuw2011} || $o/n$
|-
| colspan="4" align="center" | '''statistical'''
|-
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$\rho_{XY}$
|-
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$cov_{XY}$
|-
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence \citep{Kalousis2001a} || min,max,$\mu$,$\sigma$,$\tau_{XY}$
|-
| Sparsity || sparsity(X) || Degree of discreteness \citep{Salama2013} || min,max,$\mu$,$\sigma$
|-
| Gravity || gravity(X) || Inter-class dispersion \citep{Ali2006} ||
|-
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy \citep{kalousis02} || $p_{val_{XY}}$\citep{soares+04}
|-
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target \citep{soares+04} ||
|-
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC \citep{Michie1994} || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{Michie1994}
|-
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis
|-
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality \citep{bardenet2013collaborative} ||
|-
| Class probability || $P(\texttt{C})$ || Class distribution \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| colspan="4" align="center" | '''informational-theoretic'''
|-
| Class entropy || $H(\texttt{C})$ || Class imbalance \citep{Michie1994} ||
|-
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness \citep{Castiello2005} || min,max,$\mu$,$\sigma$
|-
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || Feature importance \citep{Agresti:2002p7509} || min,max,$\mu$,$\sigma$
|-
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality \citep{Michie1994} ||
|-
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data \citep{Michie1994} ||
|-
| colspan="4" align="center" | '''complexity'''
|-
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ \citep{Ho:2002} || See \citet{}{Ho:2002}
|-
| Volume of overlap || || Class distribution overlap \citep{Ho:2002} || See \citet{Ho:2002}
|-
| Concept variation || || Task complexity \citep{Vilalta:2002p5805} || See \citet{Vilalta:1999p5745}
|-
| Data consistency || || Data quality \citep{Kopf:2002p5864} || See \citet{Kopf:2002p5864}
|-
| colspan="4" align="center" | '''model-based'''
|-
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity \citep{Peng:2002p705} || Tree depth
|-
| Branch length || || Concept complexity \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity \citep{Filchenkov2015} || min,max,$\mu$,$\sigma$
|-
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability \citep{Bensusan2000} || min,max,$\mu$,$\sigma$
|-
| Information gain || || Feature importance \citep{Bensusan2000} || min,max,$\mu$,$\sigma$, gini
|-
| colspan="4" align="center" | '''landmarks'''
|-
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity \citep{Pfahringer:2000p553} || See \citet{Pfahringer:2000p553}
|-
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability \citep{Pfahringer:2000p553} || Stump,RandomTree
|-
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability \citep{Pfahringer:2000p553} || Lin.Disciminant
|-
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence \citep{Pfahringer:2000p553} || See \citet{Ler:2005p1680}
|-
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance \citep{Furnkranz:2001p1278} ||
|-
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance \citep{Soares:2001p708} ||
|-
|}

Непрерывные фичи $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+})$.

Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей, и должны быть агрегированы через min,max,$\mu$,$\sigma$,quartiles или гистограммами [kalousis]

Во время вычисления похожести задач важно нормализовывать все мета-фичи [bardnet], использовать feature selection [todorovski] или использовать dimensionality reduction (PCA, например).

<h2>Примечания</h2>

https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem
https://arxiv.org/pdf/1810.03548.pdf
https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf
https://openreview.net/pdf?id=rJY0-Kcll
https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf
Alexandros Kalousis and Melanie Hilario. Model selection v
ia meta-learning: a comparative
study.
Intl Journ. on Artificial Intelligence Tools
, 10(4):525–554, 2001.
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
L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP.
Lecture Notes in Computer Science, 1704:98–106, 1999.

Мета-обучение

2019-01-25T23:05:13Z

5.18.218.179: Пропущен один -, еще одна замена

<b>Мета-обучение</b> {{---}} подход, повзоляющий определять оптимальный алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свети задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-фичами. Мета-фича описывает свойство задачи {{---}} напмример, разрежен ли датасет или нет.

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

Такими задачами являются:
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек, смог определить, есть ли на новой картинке кошка
* Игровой бот, способный быстро обучиться новой игре
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности

Ограничения
- No free lunch teorem [Wolpert and Macready, 1996; Giraud-Carrier and Provost, 2005]

<h2>Simple view</h2>

Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.
Оптимальные параметры модели:

\begin{aligned}
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})]
\end{aligned}

Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.

Few-shot классификатор конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,
train set $S$ и test set $B$. Часто принимается k-shot N-class задача - train set содержит $k$ размеченных примеров для каждого из $N$ классов.
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$ и каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:

\begin{aligned}
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})] &\\
\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.}}
\end{aligned}

В few-shot классификации цель {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения, сделаем следующее:
# возьмем подмножество меток, $L\subset\mathcal{L}$
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:

\begin{aligned}
L, y \in L, \forall (x, y) \in S^L, B^L
\end{aligned}

# Множество $S^L$ подается на вход модели.
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобыона могла обобщиться до других датасетов.
Красным выделен дифф между обучением с учителем и мета-обучением.

\begin{aligned}
\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}{]}
\end{aligned}

Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того, чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.

<h2>Основанные на оптимизации</h2>

Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее, оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов, и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.

<h3>LSTM-meta-learner</h3>
Оптимизационный алгоитм может быть явно смоделирован. Ravi & Larochelle (2017) это и сделали и назвали его "meta-learner". Цель meta-learner'а - эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.

Пусть модель ученика будет $M_θ$, параметризованной $θ$, и meta-learner как $R_Θ$ с параметром $θ$, и функция потерь $\mathcal{L}$.

Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):

\begin{aligned}
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t
\end{aligned}

Обновление памяти ячейки LSTM выглядит так:

\begin{aligned}
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
\end{aligned}

$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ - не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin{aligned}
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{; как сильно мы забываем старые значения параметров.}}\\
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.}}\\
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t &\\
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t &\\
\end{aligned}

я ничего не понял..

<h3>REPTILE</h3>

Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентый спуск и оба не чувствительны к модели.

# сэмплируем задачу
# тренируемся на ней несколькими шагами градиентного спуска
# сдвигаем веса модели к новым параметрам.

$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.

<font color=green>// Algorithm REPTILE, batched version</font>
Initialize $\theta$
'''for''' $iteration = 1, 2,...$ '''do'''
Sample tasks $\tau_1, \tau_2, ..., \tau_n$
'''for''' $i = 1, 2, ..., n$ '''do'''
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$
'''end for'''
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$
'''end for'''

<h2>Определение множества конфигураций</h2>
Предшествующие выисления могут быть также использованы для изучения пространства более успешных конфигураций \theta\star. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных рессурсах.

Альтернативный подход сперва узнать оптимальные гипермараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей для этого алгоритма на большом числе задач. После того, как уже проверены многие варинаты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной.Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.

Если мы хотим предоставить рекомендации для конкретной задачи $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}$ for $t_{new}$.
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_new$ и перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.

<h3>Relative landmarks</h3>
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.

<h3>Суррогатные модели</h3>
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.

Так же можно обучать суррогатные модли на Гауссовских процессах (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}$.

Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ поулчается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).

<h3>Обучение на свойствах задачи (learning on task properties)</h3>
Каждая задача $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}$.

$L: \Theta \times M \rightarrow \textbf{P}$

В таблице представлен обзор наиболее используемых мета-фичей.

{| class="wikitable"
|+ Meta-feature
|-
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''
|-
| colspan="4" align="center" | '''simple'''
|-
| Nr instances || $n$ || Speed, Scalability \citep{Michie1994} || $p/n$, $log(n)$, log(n/p)
|-
| Nr features || $p$ || Curse of dimensionality \citep{Michie1994} || $log(p)$, % categorical
|-
| Nr classes || $c$ || Complexity, imbalance \citep{Michie1994} || ratio min/maj class
|-
| Nr missing values || $m$ || Imputation effects \citep{kalousis02} || % missing
|-
| Nr outliers || $o$ || Data noisiness \citep{Rousseeuw2011} || $o/n$
|-
| colspan="4" align="center" | '''statistical'''
|-
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$\rho_{XY}$
|-
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$cov_{XY}$
|-
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence \citep{Kalousis2001a} || min,max,$\mu$,$\sigma$,$\tau_{XY}$
|-
| Sparsity || sparsity(X) || Degree of discreteness \citep{Salama2013} || min,max,$\mu$,$\sigma$
|-
| Gravity || gravity(X) || Inter-class dispersion \citep{Ali2006} ||
|-
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy \citep{kalousis02} || $p_{val_{XY}}$\citep{soares+04}
|-
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target \citep{soares+04} ||
|-
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC \citep{Michie1994} || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{Michie1994}
|-
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis
|-
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality \citep{bardenet2013collaborative} ||
|-
| Class probability || $P(\texttt{C})$ || Class distribution \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| colspan="4" align="center" | '''informational-theoretic'''
|-
| Class entropy || $H(\texttt{C})$ || Class imbalance \citep{Michie1994} ||
|-
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness \citep{Castiello2005} || min,max,$\mu$,$\sigma$
|-
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || Feature importance \citep{Agresti:2002p7509} || min,max,$\mu$,$\sigma$
|-
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality \citep{Michie1994} ||
|-
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data \citep{Michie1994} ||
|-
| colspan="4" align="center" | '''complexity'''
|-
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ \citep{Ho:2002} || See \citet{}{Ho:2002}
|-
| Volume of overlap || || Class distribution overlap \citep{Ho:2002} || See \citet{Ho:2002}
|-
| Concept variation || || Task complexity \citep{Vilalta:2002p5805} || See \citet{Vilalta:1999p5745}
|-
| Data consistency || || Data quality \citep{Kopf:2002p5864} || See \citet{Kopf:2002p5864}
|-
| colspan="4" align="center" | '''model-based'''
|-
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity \citep{Peng:2002p705} || Tree depth
|-
| Branch length || || Concept complexity \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity \citep{Filchenkov2015} || min,max,$\mu$,$\sigma$
|-
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability \citep{Bensusan2000} || min,max,$\mu$,$\sigma$
|-
| Information gain || || Feature importance \citep{Bensusan2000} || min,max,$\mu$,$\sigma$, gini
|-
| colspan="4" align="center" | '''landmarks'''
|-
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity \citep{Pfahringer:2000p553} || See \citet{Pfahringer:2000p553}
|-
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability \citep{Pfahringer:2000p553} || Stump,RandomTree
|-
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability \citep{Pfahringer:2000p553} || Lin.Disciminant
|-
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence \citep{Pfahringer:2000p553} || See \citet{Ler:2005p1680}
|-
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance \citep{Furnkranz:2001p1278} ||
|-
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance \citep{Soares:2001p708} ||
|-
|}

Непрерывные фичи $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+})$.

Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей, и должны быть агрегированы через min,max,$\mu$,$\sigma$,quartiles или гистограммами [kalousis]

Во время вычисления похожести задач важно нормализовывать все мета-фичи [bardnet], использовать feature selection [todorovski] или использовать dimensionality reduction (PCA, например).

<h2>Примечания</h2>

https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem
https://arxiv.org/pdf/1810.03548.pdf
https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf
https://openreview.net/pdf?id=rJY0-Kcll
https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf
Alexandros Kalousis and Melanie Hilario. Model selection v
ia meta-learning: a comparative
study.
Intl Journ. on Artificial Intelligence Tools
, 10(4):525–554, 2001.
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
L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP.
Lecture Notes in Computer Science, 1704:98–106, 1999.

Мета-обучение

2019-01-25T23:03:13Z

5.18.218.179: Замена - на {{---}}

<b>Мета-обучение</b> {{---}} подход, повзоляющий определять оптимальный алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи. Основная идея мета-обучения {{---}} свети задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-фичами. Мета-фича описывает свойство задачи - напмример, разрежен ли датасет или нет.

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

Такими задачами являются:
* Классификатор, тренированный на изображениях собак и велосипедов, после некоторых показанных ему кошек, смог определить, есть ли на новой картинке кошка
* Игровой бот, способный быстро обучиться новой игре
* Робот, выполняющий задачу на пригорке во время теста даже если он тренировался на ровной поверхности

Ограничения
- No free lunch teorem [Wolpert and Macready, 1996; Giraud-Carrier and Provost, 2005]

<h2>Simple view</h2>

Хорошая модель мета-обучения должна быть обучена на множестве задач и оптимизирована для лучшей производительности на нескольких задачах,
включая такие, с которыми модель не сталкивалась ранее. Каждой задаче соответствует датасет $\mathcal{D}$, содержащий и векторы фичей и правильную разметку.
Оптимальные параметры модели:

\begin{aligned}
\theta^* = \arg\min_\theta \mathbb{E}_{\mathcal{D}\sim p(\mathcal{D})} [\mathcal{L}_\theta(\mathcal{D})]
\end{aligned}

Очень похоже на обычную задачу машинного обучения, только один датасет принимается за один сэмпл данных.

Few-shot классификатор конкретизация мета-обучения в области обучения с учителем. Датасет $\mathcal{D}$ делится на две части: $\mathcal{D}=\langle S, B\rangle$,
train set $S$ и test set $B$. Часто принимается k-shot N-class задача - train set содержит $k$ размеченных примеров для каждого из $N$ классов.
Датасет $\mathcal{D}$ содержит пары фичей и меток, $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}$ и каждая метка принадлежит известному множеству меток $\mathcal{L}$. Скажем, наш классификатор $f_θ$ с параметром $θ$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе фичей $x$, $Pθ(y|x)$
Оптимальные параметры должны максимизировать вероятность верных меток среди нескольких training sets $B⊂\mathcal{D}$:

\begin{aligned}
\theta^* &= {\arg\max}_{\theta} \mathbb{E}_{(\mathbf{x}, y)\in \mathcal{D}}[P_\theta(y \vert \mathbf{x})] &\\
\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.}}
\end{aligned}

В few-shot классификации цель {{---}} уменьшить ошибку предсказания на неразмеченных данных с данным train set для "быстрого обучения". Чтобы ускорить процесс обучения, сделаем следующее:
# возьмем подмножество меток, $L\subset\mathcal{L}$
# возьмем train set $S^L⊂D$ и train batch $B^L⊂D$. Оба содержат только данные с метками из подмножества с пункта 1:

\begin{aligned}
L, y \in L, \forall (x, y) \in S^L, B^L
\end{aligned}

# Множество $S^L$ подается на вход модели.
# Конечная оптимизация использует множество $B^L$ чтобы посчитать loss и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

Можно представить каждую пару сэмплированного датасета $(S^L,B^L)$ как одну точку. Модель обучается таким образом, чтобыона могла обобщиться до других датасетов.
Красным выделен дифф между обучением с учителем и мета-обучением.

\begin{aligned}
\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}{]}
\end{aligned}

Идея в некоторой степени аналогична использованию предварительно обученной модели в классификации изображений (ImageNet) или в языковом моделировании (большие текстовые корпуса), когда доступен только ограниченный набор образцов данных для конкретной задачи. Мета-обучение идет еще на один шаг вперед, вместо того, чтобы подстраивать ее под одну задачу, она оптимизирует модель, чтобы она была хороша для многих задач.

<h2>Основанные на оптимизации</h2>

Модели глубокого обучения (deep learning) обучаются через обратное распространение градиентов. Тем не менее, оптимизация, основанная на градиентах не разрабатывалась для работы с небольшим количеством обучающих семплов, и не сходится за малое число оптимизационных шагов. Подход в мета-обучении, основанный на оптимизации как раз про это.

<h3>LSTM-meta-learner</h3>
Оптимизационный алгоитм может быть явно смоделирован. Ravi & Larochelle (2017) это и сделали и назвали его "meta-learner". Цель meta-learner'а - эффективно обновлять параметры learner'a используя небольшой train set так, чтобы learner мог быстро адаптироваться к новым задачам.

Пусть модель ученика будет $M_θ$, параметризованной $θ$, и meta-learner как $R_Θ$ с параметром $θ$, и функция потерь $\mathcal{L}$.

Обновление параметров learner'a во время $t$ c learning rate $\alpha_t$ (шаг градиентного спуска):

\begin{aligned}
\theta_t = \theta_{t-1} - \alpha_t \nabla_{\theta_{t-1}}\mathcal{L}_t
\end{aligned}

Обновление памяти ячейки LSTM выглядит так:

\begin{aligned}
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
\end{aligned}

$c_t$ {{---}} параметры сети $\theta_t$, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde{c}_t = -\nabla_{\theta_{t-1}}\mathcal{L}_t$ - не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin{aligned}
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{; как сильно мы забываем старые значения параметров.}}\\
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.}}\\
\tilde{\theta}_t &= -\nabla_{\theta_{t-1}}\mathcal{L}_t &\\
\theta_t &= f_t \odot \theta_{t-1} + i_t \odot \tilde{\theta}_t &\\
\end{aligned}

я ничего не понял..

<h3>REPTILE</h3>

Reptile {{---}} относительно простой алгоритм мета-обучения, похожий на MAML, например, тем, что оба используют мета-оптимизацию через градиентый спуск и оба не чувствительны к модели.

# сэмплируем задачу
# тренируемся на ней несколькими шагами градиентного спуска
# сдвигаем веса модели к новым параметрам.

$\text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов на лоссе $\mathcal{L}_{\tau_i}$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta - W)/\alpha$, где $\alpha$ {{---}} размер шага, используемый функцией $SGD$.

<font color=green>// Algorithm REPTILE, batched version</font>
Initialize $\theta$
'''for''' $iteration = 1, 2,...$ '''do'''
Sample tasks $\tau_1, \tau_2, ..., \tau_n$
'''for''' $i = 1, 2, ..., n$ '''do'''
Compute $W_i = \text{SGD}(\mathcal{L}_{\tau_i}, \theta, k)$
'''end for'''
Update $\theta \leftarrow \theta + \beta 1/n \sum (W_i - \theta)$
'''end for'''

<h2>Определение множества конфигураций</h2>
Предшествующие выисления могут быть также использованы для изучения пространства более успешных конфигураций \theta\star. Более подходящие под задачу конфигурации могут серьезно ускорить поиск оптимальных моделей, это важно при ограниченных вычислительных рессурсах.

Альтернативный подход сперва узнать оптимальные гипермараметры, а потом через приращение производительности определить важность каждого из гиперпараметров. Это и было сделано в лабе OpenML, провели около 500 000 экспериментов на 6 алгоритмах и 38 датасетах. Стандартные значения изучались вместе для всех гиперпараметров алгоритма посредством обучения суррогатных моделей для этого алгоритма на большом числе задач. После того, как уже проверены многие варинаты конфигураций, выбирается такая, которая минимизирует ??? для всех задач, становится стандартной.Далее определяется важность каждого из гиперпараметров. Чем больше меняется приращение производительности, тем более важный гиперпараметр мы изменяем.

Если мы хотим предоставить рекомендации для конкретной задачи $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}$ for $t_{new}$.
Более того, можно пойти дальше и добавить $\Theta^{*}_{new}$ в $P_new$ и перейти к следующей итерации и выяснять какие еще задачи схожи друг с другом.

<h3>Relative landmarks</h3>
Первая мера для вычисления "похожести" задач вычисляла попарно разницу в производительности, так же называемую "relative landmarks" $RL_{a,b,j} = P_{a,j} - P_{b,j}$ между двумя конфигурациями $\theta_{a}$ и $\theta_{b}$ на конкретной задаче $t_{j}$.

<h3>Суррогатные модели</h3>
Более гибкий способ передать информацию {{---}} построить суррогатную модель $s_{j}(\theta_{i}) = P_{i,j}$ для всех предшествующих задач $t_{j}$, обученную с использованием всех доступных $\mathbf{P}$. Можно определить "похожесть" задач в терминах ошибок между $s_{j}(\theta_{i})$ и $P_{i,new}$: если суррогатная модель для $t_{j}$ может генерировать точные предсказания для $t_{new}$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_{i}$.

Так же можно обучать суррогатные модли на Гауссовских процессах (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}$.

Суррогатные модели обучаются только на $P_{i, new}$, а следующий $\theta_{i}$ поулчается путем нахождения средневзвешенного expected improvement $P_{i, new}$ и предсказанных улучшений на всех предшествующих $P_{i, j}$.
Веса предшествующих задач могут быть переопределены через точность суррогатной модели или через relative landmarks.
Вес ожидаемого улучшения (expected improvement) постепенно возрастает с каждой итерацией (с увеличением собранного эвиденса $P_{i, new}$).

<h3>Обучение на свойствах задачи (learning on task properties)</h3>
Каждая задача $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}$.

$L: \Theta \times M \rightarrow \textbf{P}$

В таблице представлен обзор наиболее используемых мета-фичей.

{| class="wikitable"
|+ Meta-feature
|-
! '''Name''' !! '''Formula''' !! '''Rationale''' !! '''Variants'''
|-
| colspan="4" align="center" | '''simple'''
|-
| Nr instances || $n$ || Speed, Scalability \citep{Michie1994} || $p/n$, $log(n)$, log(n/p)
|-
| Nr features || $p$ || Curse of dimensionality \citep{Michie1994} || $log(p)$, % categorical
|-
| Nr classes || $c$ || Complexity, imbalance \citep{Michie1994} || ratio min/maj class
|-
| Nr missing values || $m$ || Imputation effects \citep{kalousis02} || % missing
|-
| Nr outliers || $o$ || Data noisiness \citep{Rousseeuw2011} || $o/n$
|-
| colspan="4" align="center" | '''statistical'''
|-
| Skewness || $\frac{E(X-\mu_{X})^{3}}{\sigma_{X}^{3}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Kurtosis || $\frac{E(X-\mu_{X})^{4}}{\sigma_{X}^{4}}$ || Feature normality \citep{Michie1994} || min,max,$\mu$,$\sigma$,$q_{1},q_{3}$
|-
| Correlation || $\rho_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$\rho_{XY}$
|-
| Covariance || $cov_{X_{1}X_{2}}$ || Feature interdependence \citep{Michie1994} || min,max,$\mu$,$\sigma$,$cov_{XY}$
|-
| Concentration || $\tau_{X_{1}X_{2}}$ || Feature interdependence \citep{Kalousis2001a} || min,max,$\mu$,$\sigma$,$\tau_{XY}$
|-
| Sparsity || sparsity(X) || Degree of discreteness \citep{Salama2013} || min,max,$\mu$,$\sigma$
|-
| Gravity || gravity(X) || Inter-class dispersion \citep{Ali2006} ||
|-
| ANOVA p-value || $p_{val_{\texttt{X}_{1}X_{2}}}$ || Feature redundancy \citep{kalousis02} || $p_{val_{XY}}$\citep{soares+04}
|-
| Coeff. of variation || $\frac{\sigma_{Y}}{\mu_{Y}}$ || Variation in target \citep{soares+04} ||
|-
| PCA $\rho_{\lambda_{1}}$ || $\sqrt{\frac{\lambda_{1}}{1+\lambda_{1}}}$ || Variance in first PC \citep{Michie1994} || $\frac{\lambda_{1}}{\sum_{i} \lambda_{i}}$\citep{Michie1994}
|-
| PCA skewness || || Skewness of first PC \citep{feurer2014using} || PCA kurtosis
|-
| PCA 95\% || $\frac{dim_{95\% var}}{p}$ || Intrinsic dimensionality \citep{bardenet2013collaborative} ||
|-
| Class probability || $P(\texttt{C})$ || Class distribution \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| colspan="4" align="center" | '''informational-theoretic'''
|-
| Class entropy || $H(\texttt{C})$ || Class imbalance \citep{Michie1994} ||
|-
| Norm. entropy || $\frac{H(\texttt{X})}{log_{2}n}$ || Feature informativeness \citep{Castiello2005} || min,max,$\mu$,$\sigma$
|-
| Mutual inform. || $MI(\texttt{C},\texttt{X})$ || Feature importance \citep{Michie1994} || min,max,$\mu$,$\sigma$
|-
| Uncertainty coeff. || $\frac{MI(\texttt{C},\texttt{X})}{H(\texttt{C})}$ || Feature importance \citep{Agresti:2002p7509} || min,max,$\mu$,$\sigma$
|-
| Equiv. nr. feats || $\frac{H(C)}{\overline{MI(C,X)}}$ || Intrinsic dimensionality \citep{Michie1994} ||
|-
| Noise-signal ratio || $\frac{\overline{H(X)}-\overline{MI(C,X)}}{\overline{MI(C,X)}}$ || Noisiness of data \citep{Michie1994} ||
|-
| colspan="4" align="center" | '''complexity'''
|-
| Fisher's discrimin. || $\frac{(\mu_{c1}-\mu_{c2})^{2}}{\sigma_{c1}^{2}-\sigma_{c2}^{2}}$ || Separability classes $c_{1},c_{2}$ \citep{Ho:2002} || See \citet{}{Ho:2002}
|-
| Volume of overlap || || Class distribution overlap \citep{Ho:2002} || See \citet{Ho:2002}
|-
| Concept variation || || Task complexity \citep{Vilalta:2002p5805} || See \citet{Vilalta:1999p5745}
|-
| Data consistency || || Data quality \citep{Kopf:2002p5864} || See \citet{Kopf:2002p5864}
|-
| colspan="4" align="center" | '''model-based'''
|-
| Nr nodes, leaves || <tex>|\eta|,|\psi|</tex> || Concept complexity \citep{Peng:2002p705} || Tree depth
|-
| Branch length || || Concept complexity \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Nodes per feature || <tex>|\eta_{X}|</tex> || Feature importance \citep{Peng:2002p705} || min,max,$\mu$,$\sigma$
|-
| Leaves per class || <tex>\frac{|\psi_{c}|}{|\psi|}</tex> || Class complexity \citep{Filchenkov2015} || min,max,$\mu$,$\sigma$
|-
| Leaves agreement || <tex>\frac{n_{\psi_{i}}}{n}</tex> || Class separability \citep{Bensusan2000} || min,max,$\mu$,$\sigma$
|-
| Information gain || || Feature importance \citep{Bensusan2000} || min,max,$\mu$,$\sigma$, gini
|-
| colspan="4" align="center" | '''landmarks'''
|-
| Landmarker(1NN) || $P(\theta_{1NN},t_{j})$ || Data sparsity \citep{Pfahringer:2000p553} || See \citet{Pfahringer:2000p553}
|-
| Landmarker(Tree) || $P(\theta_{Tree},t_{j})$ || Data separability \citep{Pfahringer:2000p553} || Stump,RandomTree
|-
| Landmarker(Lin) || $P(\theta_{Lin},t_{j})$ || Linear separability \citep{Pfahringer:2000p553} || Lin.Disciminant
|-
| Landmarker(NB) || $P(\theta_{NB},t_{j})$ || Feature independence \citep{Pfahringer:2000p553} || See \citet{Ler:2005p1680}
|-
| Relative LM || $P_{a,j} - P_{b,j}$ || Probing performance \citep{Furnkranz:2001p1278} ||
|-
| Subsample LM || $P(\theta_{i},t_{j},s_{t})$ || Probing performance \citep{Soares:2001p708} ||
|-
|}

Непрерывные фичи $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+})$.

Многие мета-фичи вычисляются по одиночным фичам или комбинации фичей, и должны быть агрегированы через min,max,$\mu$,$\sigma$,quartiles или гистограммами [kalousis]

Во время вычисления похожести задач важно нормализовывать все мета-фичи [bardnet], использовать feature selection [todorovski] или использовать dimensionality reduction (PCA, например).

<h2>Примечания</h2>

https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html#define-the-meta-learning-problem
https://arxiv.org/pdf/1810.03548.pdf
https://www.ml4aad.org/wp-content/uploads/2018/09/chapter2-metalearning.pdf
https://openreview.net/pdf?id=rJY0-Kcll
https://www.fruct.org/publications/ainl-fruct/files/Fil.pdf
Alexandros Kalousis and Melanie Hilario. Model selection v
ia meta-learning: a comparative
study.
Intl Journ. on Artificial Intelligence Tools
, 10(4):525–554, 2001.
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
L Todorovski and S Dzeroski. Experiments in meta-level learning with ILP.
Lecture Notes in Computer Science, 1704:98–106, 1999.

Сверточные нейронные сети

2019-01-21T17:33:34Z

5.18.218.179: Добавлены ссылки на источники картинок, а также категории

'''Сверточная нейронная сеть''' (англ. ''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>, изначально нацеленная на эффективное распознавание изображений.

== Свертка ==
[[Файл:Convolution_example.png|upright=1.0|thumb|[https://arxiv.org/abs/1603.07285 Пример свертки двух матриц размера 5x5 и 3x3]]]
'''Свертка''' (англ. ''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>.
Каждый элемент результата вычисляется как скалярное произведение матрицы <math>B</math> и некоторой подматрицы <math>A</math> такого же размера (подматрица определяется положением элемента в результате).
То есть, <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>, на которую она сейчас наложена. Получившееся число записывается в соответствующий элемент результата.

Логический смысл свертки такой {{---}} чем больше величина элемента свертки, тем больше эта часть матрицы <math>A</math> была похожа на матрицу <math>B</math> (похожа в смысле скалярного произведения). Поэтому матрицу <math>A</math> называют ''изображением'', а матрицу <math>B</math> {{---}} ''фильтром'' или ''образцом''.

== Структура сверточной нейронной сети ==
В сверточной нейронной сети выходы промежуточных слоев образуют матрицу (изображение) или набор матриц (несколько слоёв изображения). Так, например, на вход сверточной нейронной сети можно подавать три слоя изображения (R-, G-, B-каналы изображения). Основными видами слоев в сверточной нейронной сети являются сверточные слои (англ. ''convolutional layer''), пулинговые слои (англ. ''pooling layer'') и [[:Нейронные_сети,_перцептрон|полносвязные слои]] (англ. ''fully-connected layer'').

=== Сверточный слой ===
[[Файл:Padding.png|upright=1.0|thumb|[https://arxiv.org/abs/1603.07285 Пример свертки двух матриц с дополнением нулями и сдвигом 2]]]
[[Файл:Convolution-operation-on-volume5.png|upright=1.0|thumb|[http://www.machinelearning.ru/wiki/images/1/1b/DL16_lecture_3.pdf Пример свертки с трехмерным ядром]]]
Сверточный слой нейронной сети представляет из себя применение операции свертки к выходам с предыдущего слоя, где веса ядра свертки являются обучаемыми параметрами. Еще один обучаемый вес используется в качестве константного сдвига (англ. ''bias''). При этом есть несколько важных деталей:

* В одном сверточном слое может быть несколько сверток. В этом случае для каждой свертки на выходе получится своё изображение. Например, если вход имел размерность <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>.

* Ядра свертки могут быть трёхмерными. Свертка трехмерного входа с трехмерным ядром происходит аналогично, просто скалярное произведение считается еще и по всем слоям изображения. Например, для усреднения информации о цветах исходного изображения, на первом слое можно использовать свертку размерности <math>3\times w \times h</math>. На выходе такого слоя будет уже одно изображение (вместо трёх).

* Можно заметить, что применение операции свертки уменьшает изображение. Также пиксели, которые находятся на границе изображения учавствуют в меньшем количестве сверток, чем внутренние. В связи с этим в сверточных слоях используется дополнение изображения (англ. ''padding''). Выходы с предыдущего слоя дополняются пикселями так, чтобы после свертки сохранился размер изображения. Такие свертки называют ''одинаковыми'' (англ. ''same convolution''), а свертки без дополнения изображения называются ''правильными'' (англ. ''valid convolution''). Среди способов, которыми можно заполнить новые пиксели, можно выделить следующие:
** ''zero shift'': <code>00[ABC]00</code>
** ''border extension'': <code>AA[ABC]CC</code>
** ''mirror shift'': <code>BA[ABC]CB</code>
** ''cyclic shift'': <code>BC[ABC]AB</code>

* Еще одним параметром сверточного слоя является ''сдвиг'' (англ. ''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>.

=== Пулинговый слой ===
[[Файл:Maxpool.jpeg|upright=1.0|thumb|[https://www.slideshare.net/YUNGKUEICHEN/convolutional-neural-network-cnn-image-recognition Пример операции пулинга с функцией максимума]]]
Пулинговый слой призван снижать размерность изображения. Исходное изображение делится на блоки размером <math>w\times h</math> и для каждого блока вычисляется некоторая функция. Чаще всего используется функция максимума (англ. ''max pooling'') или (взвешенного) среднего (англ. ''(weighted) average pooling''). Обучаемых параметров у этого слоя нет. Основные цели пулингового слоя:
* уменьшение изображения, чтобы последующие свертки оперировали над большей областью исходного изображения;
* увеличение инвариантности выхода сети по отношению к малому переносу входа;
* ускорение вычислений.

=== Inception module ===
[[Файл:Inception.png|upright=1.0|thumb|[https://arxiv.org/abs/1409.4842 Inception module]]]
[[Файл:Inception_red.png|upright=1.0|thumb|[https://arxiv.org/pdf/1409.4842.pdf Inception module с сокращением размерностей]]]
''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>, который схлопывает все слои изображения в один. Это позволяет сохранить малое число слоев, с сохранением полезной информации о изображении.

=== Residual block ===
[[Файл:Residual.png|upright=1.0|thumb|[https://arxiv.org/pdf/1512.03385.pdf Устройство residual block]]]
Двумя серьезными проблемами в обучении глубоких нейронных сетей являются исчезающий градиент (англ. ''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> {{---}} функция активации.

На самом деле, такая нейронная сеть обучается предсказывать функцию <math>\mathcal{F}(x) - x</math>, вместо функции <math>\mathcal{F}(x)</math>, которую изначально нужно было предсказывать. Для компенсации этой разницы и вводится это замыкающее соединение (англ. ''shortcut connection''), которое добавляет недостающий <math>x</math> к функции. Предположение авторов, которые предложили residual block, заключалось в том, что такую разностную функцию будет проще обучать, чем исходную. Если рассматривать крайние случаи, то если <math>\mathcal{F}(x) = x</math>, такую сеть обучить нулю всегда возможно, в отличие от обучения множества нелинейных слоёв линейному преобразованию.

== Известные архитектуры сверточных нейронных сетей ==
=== LeNet-5 ===
[[Файл:Lenet5.png|upright=1.0|thumb|[http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf Архитектура LeNet-5]]]
Нейронная сеть, предложенная Яном Лекуном<ref name=LeNet5/>, для распознавания рукописных цифр MNIST.

=== AlexNet ===
[[Файл:Alexnet.png|upright=1.0|thumb|[https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf Архитектура AlexNet]]]
Победитель соревнования 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 с минимальным обменом данными.

=== VGG ===
Семейство архитектур нейронных сетей, которое включает в себя, в частности, 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).

=== GoogLeNet ===
Также известный как ''inception network'' {{---}} победитель соревнования ImageNet 2014-ого года, набравший 93.3% точности<ref name=GoogLeNet/>. Состоит в основном из inception модулей. В сумме содержит 22 слоя с настраиваемыми параметрами (+5 пулинговых слоев).

=== ResNet ===
Победитель соревнования ImageNet 2015-ого года. Сеть-победитель содержала более 150 слоёв<ref name=ResNet/> и набрала 96.43% точности.

=== Сравнение известных нейронных сетей ===
[[Файл:Net-comparison.png|border|1000px]]

== Примеры кода ==
===Scala===
Пример кода с библиотекой DeepLearning.scala<ref>[https://deeplearning.thoughtworks.school/index.html DeepLearning.scala]</ref>
// Загрузка датасета
val cifar10 = Cifar10.load().blockingAwait
// Определение слоёв
def myNeuralNetwork(input: INDArray): INDArrayLayer = {
val cnnLayer = maxPool(relu(conv2d(input.reshape(input.shape()(0), Cifar10.NumberOfChannels, PixelHeight, PixelWidth), cnnWeight, cnnBias, (KernelHeight, KernelWidth), (Stride, Stride), (Padding, Padding))), (PoolSize, PoolSize))
val affineRuleOfCnnLayer = relu(affine(cnnLayer.reshape(input.shape()(0), NumFilters * (PixelHeight / PoolSize) * (PixelWidth / PoolSize)), affineWeight, affineBias))
val affineOfaffineRuleOfCnnLayer = affine(affineRuleOfCnnLayer.reshape(input.shape()(0), HiddenDim), affineLastWeight, affineLastBias)
val softmaxValue = softmax(affineOfaffineRuleOfCnnLayer)
softmaxValue
}
// Определение функции потерь
def lossFunction(input: INDArray, expectOutput: INDArray): DoubleLayer = {
val probabilities = myNeuralNetwork(input)
-(hyperparameters.log(probabilities) * expectOutput).mean
}

class Trainer(batchSize: Int, numberOfEpoches: Int = 5) {
import scalaz.std.anyVal._
import scalaz.syntax.all._
@volatile
private var isShuttingDown: Boolean = false
private val lossBuffer = scala.collection.mutable.Buffer.empty[Double]
def plotLoss(): Unit = Seq(Scatter(lossBuffer.indices, lossBuffer)).plot(title = "loss by time")
def interrupt(): Unit = isShuttingDown = true
def startTrain(): Unit = {
@monadic[Future]
def trainTask: Future[Unit] = {
isShuttingDown = false
var epoch = 0

while (epoch < numberOfEpoches && !isShuttingDown) {
val cifar10 = Cifar10.load().blockingAwait
val iterator = cifar10.epoch(batchSize).zipWithIndex
while (iterator.hasNext && !isShuttingDown) {
val (Cifar10.Batch(labels, batch), i) = iterator.next()
val loss = lossFunction(batch, labels).train.each
lossBuffer += loss
hyperparameters.logger.info(s"epoch=epoch iteration=i batchSize=batchSize loss=loss")
}
epoch += 1
}
hyperparameters.logger.info("Done")
}
trainTask.onComplete { tryUnit: scala.util.Try[Unit] => tryUnit.get }
}
}

==См. также==
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]

==Примечания==
<references/>

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]

Сверточные нейронные сети

2019-01-20T13:56:57Z

5.18.218.179:

'''Сверточная нейронная сеть''' (англ. ''convolutional neural network'', ''CNN'') {{---}} специальная архитектура нейронных сетей, предложенная Яном Лекуном<ref>[http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf Yann LeCun — Gradient-Based Learning Applied to Document Recognition, 1998]</ref>, изначально нацеленная на эффективное распознавание изображений.

== Свертка ==
[[Файл:Convolution_example.png|upright=1.0|thumb|Пример свертки двух матриц размера 5x5 и 3x3]]
'''Свертка''' (англ. ''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>.
Каждый элемент результата вычисляется как скалярное произведение матрицы <math>B</math> и некоторой подматрицы <math>A</math> такого же размера (подматрица определяется положением элемента в результате).
То есть, <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>, на которую она сейчас наложена. Получившееся число записывается в соответствующий элемент результата.

Логический смысл свертки такой {{---}} чем больше величина элемента свертки, тем больше эта часть матрицы <math>A</math> была похожа на матрицу <math>B</math> (похожа в смысле скалярного произведения). Поэтому матрицу <math>A</math> называют ''изображением'', а матрицу <math>B</math> {{---}} ''фильтром'' или ''образцом''.

== Структура сверточной нейронной сети ==
В сверточной нейронной сети выходы промежуточных слоев образуют матрицу (изображение) или набор матриц (несколько слоёв изображения). Так, например, на вход сверточной нейронной сети можно подавать три слоя изображения (R-, G-, B-каналы изображения). Основными видами слоев в сверточной нейронной сети являются сверточные слои (англ. ''convolutional layer''), пулинговые слои (англ. ''pooling layer'') и [[:Нейронные_сети,_перцептрон|полносвязные слои]] (англ. ''fully-connected layer'').

=== Сверточный слой ===
[[Файл:Padding.png|upright=1.0|thumb|Пример свертки двух матриц с дополнением нулями и сдвигом 2]]
[[Файл:Convolution-operation-on-volume5.png|upright=1.0|thumb|Пример свертки с трехмерным ядром]]
Сверточный слой нейронной сети представляет из себя применение операции свертки к выходам с предыдущего слоя, где веса ядра свертки являются обучаемыми параметрами. Еще один обучаемый вес используется в качестве константного сдвига (англ. ''bias''). При этом есть несколько важных деталей:

* В одном сверточном слое может быть несколько сверток. В этом случае для каждой свертки на выходе получится своё изображение. Например, если вход имел размерность <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>.

* Ядра свертки могут быть трёхмерными. Свертка трехмерного входа с трехмерным ядром происходит аналогично, просто скалярное произведение считается еще и по всем слоям изображения. Например, для усреднения информации о цветах исходного изображения, на первом слое можно использовать свертку размерности <math>3\times w \times h</math>. На выходе такого слоя будет уже одно изображение (вместо трёх).

* Можно заметить, что применение операции свертки уменьшает изображение. Также пиксели, которые находятся на границе изображения учавствуют в меньшем количестве сверток, чем внутренние. В связи с этим в сверточных слоях используется дополнение изображения (англ. ''padding''). Выходы с предыдущего слоя дополняются пикселями так, чтобы после свертки сохранился размер изображения. Такие свертки называют ''одинаковыми'' (англ. ''same convolution''), а свертки без дополнения изображения называются ''правильными'' (англ. ''valid convolution''). Среди способов, которыми можно заполнить новые пиксели, можно выделить следующие:
** ''zero shift'': <code>00[ABC]00</code>
** ''border extension'': <code>AA[ABC]CC</code>
** ''mirror shift'': <code>BA[ABC]CB</code>
** ''cyclic shift'': <code>BC[ABC]AB</code>

* Еще одним параметром сверточного слоя является ''сдвиг'' (англ. ''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>.

=== Пулинговый слой ===
[[Файл:Maxpool.jpeg|upright=1.0|thumb|Пример операции пулинга с функцией максимума]]
Пулинговый слой призван снижать размерность изображения. Исходное изображение делится на блоки размером <math>w\times h</math> и для каждого блока вычисляется некоторая функция. Чаще всего используется функция максимума (англ. ''max pooling'') или (взвешенного) среднего (англ. ''(weighted) average pooling''). Обучаемых параметров у этого слоя нет. Основные цели пулингового слоя:
* уменьшение изображения, чтобы последующие свертки оперировали над большей областью исходного изображения;
* увеличение инвариантности выхода сети по отношению к малому переносу входа;
* ускорение вычислений.

=== Inception module ===

== Известные архитектуры сверточных нейронных сетей ==
=== LeNet-5 ===
[[Файл:Lenet5.png|upright=1.0|thumb|Архитектура LeNet-5]]
Нейронная сеть, предложенная Яном Лекуном, для распознавания рукописных цифр MNIST.

=== AlexNet ===
[[Файл:Alexnet.png|upright=1.0|thumb|Архитектура AlexNet]]
Победитель соревнования ImageNet 2012-ого года, набравший точность 84.6%. Была реализована с использованием CUDA для повышения производительности. Состоит из двух отдельных частей, которые слабо взаимодействуют друг с другом, что позволяет исполнять их параллельно на разных GPU с минимальным обменом данными.

=== VGG ===
Семейство архитектур нейронных сетей, которое включает в себя, в частности, VGG-11, VGG-13, VGG-16 и VGG-19. Победитель соревнования ImageNet 2013-ого года (VGG-16), набравший точность 92.7%. Одной из отличительных особенностей является использование ядер свертки небольшого размера (3x3, в отличие от больших ядер размера 7x7 или 11x11).

== Примеры кода ==
===Scala===
Пример кода с библиотекой DeepLearning.scala<ref>[https://deeplearning.thoughtworks.school/index.html DeepLearning.scala]</ref>
// Загрузка датасета
val cifar10 = Cifar10.load().blockingAwait
// Определение слоёв
def myNeuralNetwork(input: INDArray): INDArrayLayer = {
val cnnLayer = maxPool(relu(conv2d(input.reshape(input.shape()(0), Cifar10.NumberOfChannels, PixelHeight, PixelWidth), cnnWeight, cnnBias, (KernelHeight, KernelWidth), (Stride, Stride), (Padding, Padding))), (PoolSize, PoolSize))
val affineRuleOfCnnLayer = relu(affine(cnnLayer.reshape(input.shape()(0), NumFilters * (PixelHeight / PoolSize) * (PixelWidth / PoolSize)), affineWeight, affineBias))
val affineOfaffineRuleOfCnnLayer = affine(affineRuleOfCnnLayer.reshape(input.shape()(0), HiddenDim), affineLastWeight, affineLastBias)
val softmaxValue = softmax(affineOfaffineRuleOfCnnLayer)
softmaxValue
}
// Определение функции потерь
def lossFunction(input: INDArray, expectOutput: INDArray): DoubleLayer = {
val probabilities = myNeuralNetwork(input)
-(hyperparameters.log(probabilities) * expectOutput).mean
}

class Trainer(batchSize: Int, numberOfEpoches: Int = 5) {
import scalaz.std.anyVal._
import scalaz.syntax.all._
@volatile
private var isShuttingDown: Boolean = false
private val lossBuffer = scala.collection.mutable.Buffer.empty[Double]
def plotLoss(): Unit = Seq(Scatter(lossBuffer.indices, lossBuffer)).plot(title = "loss by time")
def interrupt(): Unit = isShuttingDown = true
def startTrain(): Unit = {
@monadic[Future]
def trainTask: Future[Unit] = {
isShuttingDown = false
var epoch = 0

while (epoch < numberOfEpoches && !isShuttingDown) {
val cifar10 = Cifar10.load().blockingAwait
val iterator = cifar10.epoch(batchSize).zipWithIndex
while (iterator.hasNext && !isShuttingDown) {
val (Cifar10.Batch(labels, batch), i) = iterator.next()
val loss = lossFunction(batch, labels).train.each
lossBuffer += loss
hyperparameters.logger.info(s"epoch=epoch iteration=i batchSize=batchSize loss=loss")
}
epoch += 1
}
hyperparameters.logger.info("Done")
}
trainTask.onComplete { tryUnit: scala.util.Try[Unit] => tryUnit.get }
}
}

==См. также==
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]

==Примечания==
<references/>

Сверточные нейронные сети

2019-01-20T13:34:07Z

5.18.218.179:

'''Сверточная нейронная сеть''' (англ. ''convolutional neural network'', ''CNN'') {{---}} специальная архитектура нейронных сетей, предложенная [https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BA%D1%83%D0%BD,_%D0%AF%D0%BD Яном Лекуном], изначально нацеленная на эффективное распознавание изображений.

== Свертка ==
[[Файл:Convolution_example.png|upright=1.0|thumb|Пример свертки двух матриц размера 5x5 и 3x3]]
'''Свертка''' (англ. ''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>.
Каждый элемент результата вычисляется как скалярное произведение матрицы <math>B</math> и некоторой подматрицы <math>A</math> такого же размера (подматрица определяется положением элемента в результате).
То есть, <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>, на которую она сейчас наложена. Получившееся число записывается в соответствующий элемент результата.

Логический смысл свертки такой {{---}} чем больше величина элемента свертки, тем больше эта часть матрицы <math>A</math> была похожа на матрицу <math>B</math> (похожа в смысле скалярного произведения). Поэтому матрицу <math>A</math> называют ''изображением'', а матрицу <math>B</math> {{---}} ''фильтром'' или ''образцом''.

== Структура сверточной нейронной сети ==
В сверточной нейронной сети выходы промежуточных слоев образуют матрицу (изображение) или набор матриц (несколько слоёв изображения). Так, например, на вход сверточной нейронной сети можно подавать три слоя изображения (R-, G-, B-каналы изображения). Основными видами слоев в сверточной нейронной сети являются сверточные слои (англ. ''convolutional layer''), пулинговые слои (англ. ''pooling layer'') и [[:Нейронные_сети,_перцептрон|полносвязные слои]] (англ. ''fully-connected layer'').

=== Сверточный слой ===
[[Файл:Padding.png|upright=1.0|thumb|Пример свертки двух матриц с дополнением нулями и сдвигом 2]]
[[Файл:Convolution-operation-on-volume5.png|upright=1.0|thumb|Пример свертки с трехмерным ядром]]
Сверточный слой нейронной сети представляет из себя применение операции свертки к выходам с предыдущего слоя, где веса ядра свертки являются обучаемыми параметрами. Еще один обучаемый вес используется в качестве константного сдвига (англ. ''bias''). При этом есть несколько важных деталей:

* В одном сверточном слое может быть несколько сверток. В этом случае для каждой свертки на выходе получится своё изображение. Например, если вход имел размерность <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>.

* Ядра свертки могут быть трёхмерными. Свертка трехмерного входа с трехмерным ядром происходит аналогично, просто скалярное произведение считается еще и по всем слоям изображения. Например, для усреднения информации о цветах исходного изображения, на первом слое можно использовать свертку размерности <math>3\times w \times h</math>. На выходе такого слоя будет уже одно изображение (вместо трёх).

* Можно заметить, что применение операции свертки уменьшает изображение. Также пиксели, которые находятся на границе изображения учавствуют в меньшем количестве сверток, чем внутренние. В связи с этим в сверточных слоях используется дополнение изображения (англ. ''padding''). Выходы с предыдущего слоя дополняются пикселями так, чтобы после свертки сохранился размер изображения. Такие свертки называют ''одинаковыми'' (англ. ''same convolution''), а свертки без дополнения изображения называются ''правильными'' (англ. ''valid convolution''). Среди способов, которыми можно заполнить новые пиксели, можно выделить следующие:
** ''zero shift'': <code>00[ABC]00</code>
** ''border extension'': <code>AA[ABC]CC</code>
** ''mirror shift'': <code>BA[ABC]CB</code>
** ''cyclic shift'': <code>BC[ABC]AB</code>

* Еще одним параметром сверточного слоя является ''сдвиг'' (англ. ''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>.

=== Пулинговый слой ===
[[Файл:Maxpool.jpeg|upright=1.0|thumb|Пример операции пулинга с функцией максимума]]
Пулинговый слой призван снижать размерность изображения. Исходное изображение делится на блоки размером <math>w\times h</math> и для каждого блока вычисляется некоторая функция. Чаще всего используется функция максимума (англ. ''max pooling'') или (взвешенного) среднего (англ. ''(weighted) average pooling''). Обучаемых параметров у этого слоя нет. Основные цели пулингового слоя:
* уменьшение изображения, чтобы последующие свертки оперировали над большей областью исходного изображения;
* увеличение инвариантности выхода сети по отношению к малому переносу входа;
* ускорение вычислений.

== Известные архитектуры сверточных нейронных сетей ==
=== LeNet-5 ===
[[Файл:Lenet5.png|upright=1.0|thumb|Архитектура LeNet-5]]
Нейронная сеть, предложенная Яном Лекуном, для распознавания рукописных цифр MNIST.

=== AlexNet ===
[[Файл:Alexnet.png|upright=1.0|thumb|Архитектура AlexNet]]
Победитель соревнования ImageNet 2012-ого года, набравший точность 84.6%. Была реализована с использованием CUDA для повышения производительности. Состоит из двух отдельных частей, которые слабо взаимодействуют друг с другом, что позволяет исполнять их параллельно на разных GPU с минимальным обменом данными.

=== VGG ===
Семейство архитектур нейронных сетей, которое включает в себя, в частности, VGG-11, VGG-13, VGG-16 и VGG-19. Победитель соревнования ImageNet 2013-ого года (VGG-16), набравший точность 92.7%. Одной из отличительных особенностей является использование ядер свертки небольшого размера (3x3, в отличие от больших ядер размера 7x7 или 11x11).

== Примеры кода ==
===Scala===
Пример кода с библиотекой DeepLearning.scala<ref>[https://deeplearning.thoughtworks.school/index.html DeepLearning.scala]</ref>
// Загрузка датасета
val cifar10 = Cifar10.load().blockingAwait
// Определение слоёв
def myNeuralNetwork(input: INDArray): INDArrayLayer = {
val cnnLayer = maxPool(relu(conv2d(input.reshape(input.shape()(0), Cifar10.NumberOfChannels, PixelHeight, PixelWidth), cnnWeight, cnnBias, (KernelHeight, KernelWidth), (Stride, Stride), (Padding, Padding))), (PoolSize, PoolSize))
val affineRuleOfCnnLayer = relu(affine(cnnLayer.reshape(input.shape()(0), NumFilters * (PixelHeight / PoolSize) * (PixelWidth / PoolSize)), affineWeight, affineBias))
val affineOfaffineRuleOfCnnLayer = affine(affineRuleOfCnnLayer.reshape(input.shape()(0), HiddenDim), affineLastWeight, affineLastBias)
val softmaxValue = softmax(affineOfaffineRuleOfCnnLayer)
softmaxValue
}
// Определение функции потерь
def lossFunction(input: INDArray, expectOutput: INDArray): DoubleLayer = {
val probabilities = myNeuralNetwork(input)
-(hyperparameters.log(probabilities) * expectOutput).mean
}

class Trainer(batchSize: Int, numberOfEpoches: Int = 5) {
import scalaz.std.anyVal._
import scalaz.syntax.all._
@volatile
private var isShuttingDown: Boolean = false
private val lossBuffer = scala.collection.mutable.Buffer.empty[Double]
def plotLoss(): Unit = Seq(Scatter(lossBuffer.indices, lossBuffer)).plot(title = "loss by time")
def interrupt(): Unit = isShuttingDown = true
def startTrain(): Unit = {
@monadic[Future]
def trainTask: Future[Unit] = {
isShuttingDown = false
var epoch = 0

while (epoch < numberOfEpoches && !isShuttingDown) {
val cifar10 = Cifar10.load().blockingAwait
val iterator = cifar10.epoch(batchSize).zipWithIndex
while (iterator.hasNext && !isShuttingDown) {
val (Cifar10.Batch(labels, batch), i) = iterator.next()
val loss = lossFunction(batch, labels).train.each
lossBuffer += loss
hyperparameters.logger.info(s"epoch=epoch iteration=i batchSize=batchSize loss=loss")
}
epoch += 1
}
hyperparameters.logger.info("Done")
}
trainTask.onComplete { tryUnit: scala.util.Try[Unit] => tryUnit.get }
}
}

==См. также==
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]

==Примечания==
<references/>

Сверточные нейронные сети

2019-01-20T13:32:44Z

5.18.218.179:

Сверточные нейронные сети

2019-01-20T13:30:53Z

5.18.218.179:

Файл:Convolution-operation-on-volume5.png

2019-01-20T13:28:44Z

5.18.218.179:

Источник: http://www.machinelearning.ru/wiki/images/1/1b/DL16_lecture_3.pdf

Файл:Alexnet.png

2019-01-20T13:26:40Z

5.18.218.179:

Архитектура сверточной нейронной сети AlexNet.
Источник: https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf

Файл:Lenet5.png

2019-01-20T13:25:37Z

5.18.218.179:

Архитектура сверточной нейронной сети LeNet-5.
Источник: http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf

Файл:Maxpool.jpeg

2019-01-20T13:25:10Z

5.18.218.179:

Пример операции пулинга с функцией максимума.
Источник: https://www.slideshare.net/YUNGKUEICHEN/convolutional-neural-network-cnn-image-recognition

Файл:Padding.png

2019-01-20T13:20:29Z

5.18.218.179:

Пример свертки с дополнением изображения нулями и сдвигом 2.
Источник: https://arxiv.org/abs/1603.07285

Файл:Convolution example.png

2019-01-20T13:20:12Z

5.18.218.179:

Пример свертки двух матриц
Источник: https://arxiv.org/abs/1603.07285

Сверточные нейронные сети

2019-01-19T21:50:00Z

5.18.218.179:

'''Сверточная нейронная сеть''' (англ. ''convolutional neural network'', ''CNN'') {{---}} специальная архитектура нейронных сетей, предложенная [https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BA%D1%83%D0%BD,_%D0%AF%D0%BD Яном Лекуном], изначально нацеленная на эффективное распознавание изображений.

== Свертка ==
[[Файл:Convolution_example.png|upright=1.0|thumb|Пример свертки двух матриц размера 5x5 и 3x3]]
'''Свертка''' (англ. ''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>.
Каждый элемент результата вычисляется как скалярное произведение матрицы <math>B</math> и некоторой подматрицы <math>A</math> такого же размера (подматрица определяется положением элемента в результате).
То есть, <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>, на которую она сейчас наложена. Получившееся число записывается в соответствующий элемент результата.

Логический смысл свертки такой {{---}} чем больше величина элемента свертки, тем больше эта часть матрицы <math>A</math> была похожа на матрицу <math>B</math> (похожа в смысле скалярного произведения). Поэтому матрицу <math>A</math> называют ''изображением'', а матрицу <math>B</math> {{---}} ''фильтром'' или ''образцом''.

== Структура сверточной нейронной сети ==
В сверточной нейронной сети выходы промежуточных слоев образуют матрицу (изображение) или набор матриц (несколько слоёв изображения). Так, например, на вход сверточной нейронной сети можно подавать три слоя изображения (R-, G-, B-каналы изображения). Основными видами слоев в сверточной нейронной сети являются сверточные слои (англ. ''convolutional layer''), пулинговые слои (англ. ''pooling layer'') и [[:Нейронные сети, перцептрон|полносвязные слои]]<sup>[на 09.01.19 не создан]</sup> (англ. ''fully-connected layer'').

=== Сверточный слой ===
[[Файл:Padding.png|upright=1.0|thumb|Пример свертки двух матриц с дополнением нулями и сдвигом 2]]
[[Файл:Convolution-operation-on-volume5.png|upright=1.0|thumb|Пример свертки с трехмерным ядром]]
Сверточный слой нейронной сети представляет из себя применение операции свертки к выходам с предыдущего слоя, где веса ядра свертки являются обучаемыми параметрами. Еще один обучаемый вес используется в качестве константного сдвига (англ. ''bias''). При этом есть несколько важных деталей:

* В одном сверточном слое может быть несколько сверток. В этом случае для каждой свертки на выходе получится своё изображение. Например, если вход имел размерность <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>.

* Ядра свертки могут быть трёхмерными. Свертка трехмерного входа с трехмерным ядром происходит аналогично, просто скалярное произведение считается еще и по всем слоям изображения. Например, для усреднения информации о цветах исходного изображения, на первом слое можно использовать свертку размерности <math>3\times w \times h</math>. На выходе такого слоя будет уже одно изображение (вместо трёх).

* Можно заметить, что применение операции свертки уменьшает изображение. Также пиксели, которые находятся на границе изображения учавствуют в меньшем количестве сверток, чем внутренние. В связи с этим в сверточных слоях используется дополнение изображения (англ. ''padding''). Выходы с предыдущего слоя дополняются пикселями так, чтобы после свертки сохранился размер изображения. Такие свертки называют ''одинаковыми'' (англ. ''same convolution''), а свертки без дополнения изображения называются ''правильными'' (англ. ''valid convolution''). Среди способов, которыми можно заполнить новые пиксели, можно выделить следующие:
** ''zero shift'': <code>00[ABC]00</code>
** ''border extension'': <code>AA[ABC]CC</code>
** ''mirror shift'': <code>BA[ABC]CB</code>
** ''cyclic shift'': <code>BC[ABC]AB</code>

* Еще одним параметром сверточного слоя является ''сдвиг'' (англ. ''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>.

=== Пулинговый слой ===
[[Файл:Maxpool.jpeg|upright=1.0|thumb|Пример операции пулинга с функцией максимума]]
Пулинговый слой призван снижать размерность изображения. Исходное изображение делится на блоки размером <math>w\times h</math> и для каждого блока вычисляется некоторая функция. Чаще всего используется функция максимума (англ. ''max pooling'') или (взвешенного) среднего (англ. ''(weighted) average pooling''). Обучаемых параметров у этого слоя нет. Основные цели пулингового слоя:
* уменьшение изображения, чтобы последующие свертки оперировали над большей областью исходного изображения;
* увеличение инвариантности выхода сети по отношению к малому переносу входа;
* ускорение вычислений.

== Известные архитектуры сверточных нейронных сетей ==
=== LeNet-5 ===
[[Файл:Lenet5.png|upright=1.0|thumb|Архитектура LeNet-5]]
Нейронная сеть, предложенная Яном Лекуном, для распознавания рукописных цифр MNIST.

=== AlexNet ===
[[Файл:Alexnet.png|upright=1.0|thumb|Архитектура AlexNet]]
Победитель соревнования ImageNet 2012-ого года, набравший точность 84.6%. Была реализована с использованием CUDA для повышения производительности. Состоит из двух отдельных частей, которые слабо взаимодействуют друг с другом, что позволяет исполнять их параллельно на разных GPU с минимальным обменом данными.

=== VGG ===
Семейство архитектур нейронных сетей, которое включает в себя, в частности, VGG-11, VGG-13, VGG-16 и VGG-19. Победитель соревнования ImageNet 2013-ого года (VGG-16), набравший точность 92.7%. Одной из отличительных особенностей является использование ядер свертки небольшого размера (3x3, в отличие от больших ядер размера 7x7 или 11x11).

== Примеры кода ==
===Scala===
Пример кода с библиотекой DeepLearning.scala<ref>[https://deeplearning.thoughtworks.school/index.html DeepLearning.scala]</ref>
// Загрузка датасета
val cifar10 = Cifar10.load().blockingAwait
// Определение слоёв
def myNeuralNetwork(input: INDArray): INDArrayLayer = {
val cnnLayer = maxPool(relu(conv2d(input.reshape(input.shape()(0), Cifar10.NumberOfChannels, PixelHeight, PixelWidth), cnnWeight, cnnBias, (KernelHeight, KernelWidth), (Stride, Stride), (Padding, Padding))), (PoolSize, PoolSize))
val affineRuleOfCnnLayer = relu(affine(cnnLayer.reshape(input.shape()(0), NumFilters * (PixelHeight / PoolSize) * (PixelWidth / PoolSize)), affineWeight, affineBias))
val affineOfaffineRuleOfCnnLayer = affine(affineRuleOfCnnLayer.reshape(input.shape()(0), HiddenDim), affineLastWeight, affineLastBias)
val softmaxValue = softmax(affineOfaffineRuleOfCnnLayer)
softmaxValue
}
// Определение функции потерь
def lossFunction(input: INDArray, expectOutput: INDArray): DoubleLayer = {
val probabilities = myNeuralNetwork(input)
-(hyperparameters.log(probabilities) * expectOutput).mean
}

class Trainer(batchSize: Int, numberOfEpoches: Int = 5) {
import scalaz.std.anyVal._
import scalaz.syntax.all._
@volatile
private var isShuttingDown: Boolean = false
private val lossBuffer = scala.collection.mutable.Buffer.empty[Double]
def plotLoss(): Unit = Seq(Scatter(lossBuffer.indices, lossBuffer)).plot(title = "loss by time")
def interrupt(): Unit = isShuttingDown = true
def startTrain(): Unit = {
@monadic[Future]
def trainTask: Future[Unit] = {
isShuttingDown = false
var epoch = 0

while (epoch < numberOfEpoches && !isShuttingDown) {
val cifar10 = Cifar10.load().blockingAwait
val iterator = cifar10.epoch(batchSize).zipWithIndex
while (iterator.hasNext && !isShuttingDown) {
val (Cifar10.Batch(labels, batch), i) = iterator.next()
val loss = lossFunction(batch, labels).train.each
lossBuffer += loss
hyperparameters.logger.info(s"epoch=epoch iteration=i batchSize=batchSize loss=loss")
}
epoch += 1
}
hyperparameters.logger.info("Done")
}
trainTask.onComplete { tryUnit: scala.util.Try[Unit] => tryUnit.get }
}
}
_

Сверточные нейронные сети

2019-01-10T09:49:29Z

5.18.218.179:

Файл:Padding.png

2019-01-10T09:22:45Z

5.18.218.179:

Пример свертки с дополнением изображения нулями и сдвигом 2.