Meta learning что это

Мета-обучение: научиться быстро учиться

Нынешние агенты ИИ преуспели в овладении определенными навыками, такими как классификация объектов, предсказание катастрофы и т. д. Однако теперь ИИ широко используется в повседневной жизни. Почти каждая организация сейчас использует ИИ в своих продуктах. Поэтому необходим единый агент ИИ, способный решать самые разные задачи. Хорошая модель машинного обучения часто требует обучения с большим количеством образцов. Люди, напротив, усваивают новые понятия и навыки намного быстрее и эффективнее. Дети, которые видели кошек и птиц всего несколько раз, могут быстро отличить их друг от друга. Подобно людям, модели машинного обучения должны быть универсальными и адаптироваться к новой проблеме с наименьшим количеством выборок. По сути, это метаобучение направлено на решение.

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

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

Подходы к метаобучению

Существует два популярных подхода к метаобучению.

Простой вид

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

здесь один набор данных рассматривается как одна точка выборки данных.

Малократная классификация

Методическая классификация — это воплощение метаобучения в области обучения с учителем. Набор данных D часто делится на две части: набор поддержки S для обучения и набор прогнозов B для обучения или тестирования, D=(S, B). Часто мы рассматриваем задачу K-кратной классификации N-классов: опорный набор содержит K помеченных примеров для каждого из N классов.

Набор данных D содержит пары векторов объектов и меток, и каждая метка принадлежит известному набору меток L. Допустим, наш классификатор f выводит вероятность того, что точка данных принадлежит классу y, учитывая вектор признаковx , Pθ(y|x). Оптимальные параметры должны максимизировать вероятность истинных меток для нескольких обучающих пакетов B⊂D:

В классификации с несколькими выстрелами цель состоит в том, чтобы уменьшить ошибку предсказания для выборок данных с неизвестными метками, учитывая небольшой набор поддержки для «быстрого обучения» (подумайте о том, как работает «точная настройка»). Чтобы процесс обучения имитировал то, что происходит во время вывода, мы хотели бы «подделать» наборы данных с подмножеством меток, чтобы не подвергать модели все метки, и соответствующим образом изменить процедуру оптимизации, чтобы стимулировать быстрое обучение:

1. Образец подмножества ярлыков.
2. Образец вспомогательного набора и обучающей партии. Оба они содержат только точки данных с метками, принадлежащими выбранному набору меток.
3. Набор поддержки является частью входных данных модели.
4. Окончательная оптимизация использует мини-пакет для вычисления потерь и обновления параметров модели посредством обратного распространения точно так же, как мы используем его в обучении с учителем.

Мы можем рассматривать каждую пару выборочных наборов данных как одну точку данных. Модель обучена таким образом, чтобы ее можно было обобщить на другие наборы данных. Символы красного цвета добавляются для метаобучения в дополнение к цели контролируемого обучения.

Ученик и мета-обучающийся

Другой популярный взгляд на метаобучение разделяет обновление модели на два этапа:

• Классификатор — это обучаемая модель, обученная выполнению заданной задачи.
• Тем временем оптимизатор учится обновлять параметры модели учащегося с помощью вспомогательного набора.

Давайте рассмотрим, что происходит при обычном контролируемом обучении. На рисунке ниже M — нейронная сеть с начальными весами (синие ■), L — вычисляет функцию потерь, а O — оптимизатор. с параметрами (розовый ★). Для каждой выборки данных модель прогнозирует, находит потери и оптимизирует веса модели. Это происходит в цикле.

В метаобучении модель M называется обучаемый, а оптимизатор Oназывается метаобучаемый. . Параметры мета-обучения изучаются путем обратного распространения градиента мета-потери по самому процессу обучения, обратно к начальным весам модели и/или к параметрам оптимизатора.

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

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

Как Meta Learning помог выиграть хакатон

История о трех бессонных ночах ресерча и преисполнении в познании.

В этой статье я расскажу о том, как мы поучаствовали в хакатоне “Цифровой прорыв” в северо-западном федеральном округе, и познакомлю вас с концепцией Meta Learning, которая позволила нам построить достойный алгоритм и победить!

Содержание:

Что такое Meta Learning?

Описание кейса

Мы выбрали кейс от Центрального Банка о прогнозировании макроэнономических показателей, соответственно, занимались предсказанием временных рядов.

Описание данных:

train часть представляля из себя 69 размеченных рядов

по 200 точек в каждом.

test часть состояла

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

Дополнительно train часть содержала лист со значениями по кварталам, соответсвенно, в некоторых из test-файлов нужно было предсказывать и квартальные значения.

Вопросы вызывали две вещи:

Скудное количество train данных

Неопределенность в фичах в test-датасетах

Поясняю второй пункт: если для train датасета мы знали, какие показатели нам даны (ВВП, уровень инфляции и т.д.), то в test части столбцы были зашифрованы. Мы, привыкшие решать более классические supervised задачи, были немного смущены этим фактом, но решение само нашло себя.

Что такое Meta Learning?

В ознакомительных англоязычных статьях чаще всего встречается неформальное определение по типу “learning to learn”.

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

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

Как по мне, чем-то напоминает идею fine-tuning’а (transfer learning’а), но я бы отметил, что при таком подходе мы все же хотим обучить базовый алгоритм на огромных массивах данных и иметь представление о схожести задачи, на которую мы будем дообучаться, с задачей, которую мы уже умеем решать. Meta Learning не всегда требует этого от нас.

Если вы хотите больше проникнуться данной концепцией, то вот статьи, которые я могу порекомендовать:

A Gentle Introduction to Meta-Learning by Edward Ma

From zero to research — An introduction to Meta-learning by Thomas Wolf

Я же расскажу о том, что сделали конкретно мы.

Наше решение

Мы подумали, что круто было бы обучить не одну модель, пытающуюся предсказывать все ряды из test’а, а подбирать оптимальную модель для каждого нового ряда из test-выборки.

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

Но как понять, какой алгоритм использовать в каждом отдельном случае?

Мы и наше время не бесконечны, поэтому давайте выберем N моделей, которые могли бы подойти. Для этого мы (относительно) быстро прогнали кросс-валидацию для train’е и с помощью PyCaret (https://habr.com/ru/company/otus/blog/497770/) сравнили между собой более 60-ти алгоритмов и выбрали 6 (Prophet, ARIMA, SARIMA, Theta, Holt-Winters, STLF) наиболее успешных.

Теперь давайте посмотрим на ряды, которые мы имеем в train части, из каждого извлечем основные эконометрические фичи (количество точек, mean, std, энтропия, степень линейности, etc), прогоним на нем кросс-валидацией N моделей, которые мы хотим сравнивать и по заданной метрике посмотрим, какая из них лучше справилась с задачей!

Таким образом, мы получим meta train dataset, где будут уже не сами ряды, а их мета-признаки (порядка 40 штук); тип модели, проявившей себя лучшим образом; ее параметры и средняя метрика (R-Squared) после CV.

Затем мы введем в игру главную мета-модель, которая по полученным выше данным научиться решать классическую задачу классификации на N классов (в нашем случае каждый класс — определенная модель)

Как с этими знаниями делать предсказания?

Теперь все просто: получая новый ряд, мы извлекаем его мета-признаки, отдаем их мета-моделе, принимающей решение (a.k.a. Сахипзадовна Ильвира Набиуллина), какой алгоритм для предсказания мы будем использовать.

Валидируемся на известной части test-сета и настраиваем гипер-параметры и делаем долгожданное предсказание.

Было бы идеально расширить train set данными из интернета, но мы делали meta train dataset практически всю первую ночь. При его кратном увеличении мы бы получили его к закрытию хакатона).

Поэтому пришлось тюнить мета-модели аккуратнее. По дефолту Kats предлагает использовать RandomForestClassifier с 500 деревьями. Я лично отвечал за эту часть. На мой взгляд, на 69 сэмплах такой лес очень просто переобучится, поэтому я экспериментировал с моделями проще (RandomTreeClaffier, LogisticRegression, KNN, NaiveBayes).

Из полученных шагов мы написали pipeline, который и запустили в последние 3 часа.

В реализации описанных шагов, нам помогла чудесная open-source библиотека Kats, которая как раз и использует концепцую Meta Learning’а для предсказания временных рядов.

Ссылка на GiHub: (горячо рекомендую директорию tutorials) ****

Напоследок

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

Мы были заряжены узнать и попробовать что-то принципиально новое лично для нас, и это стремление полностью оправдало себя. Будьте открытыми людям и идеям вокруг!

�� From zero to research — An introduction to Meta-learning

Meta-learning is an exciting trend of research in the machine-learning community which tackles the problem of learning to learn.

The traditional paradigm in machine learning research is to get a huge dataset on a specific task, and train a model from scratch using this dataset. Obviously that’s very far from how humans leverage past experiences to learn very quickly a new task from only a handset of examples.

That’s because humans learn to learn [1].

Over the last months, I have been playing and experimenting quite a lot with meta-learning models for Natural Language Processing and will be presenting some of this work at ICLR, next month in Vancouver ���� — come say hi! ��

In this post, I will start by explaining what’s meta-learning in a very visual and intuitive way. Then, we will code a meta-learning model in PyTorch and I will share some of the lessons learned on this project.

What’s learning in the first place?

Let’s have a quick look at what happens when we train a simple neural net to classify images of dogs and cats. Let’s say we have a single training image of a cat together with a label indicating that this image represents a cat [2]. I made a quick animation of a training step to save us a few thousand sentences.

The backward pass (“backprop”) is a key step when we train a neural net. Since the computations performed by the neural network and the loss are differentiable functions [3], we can compute the gradient that should be applied to each parameter of the neural net to reduce the difference between the label currently predicted by the neural net and the real/target label (this difference is measured by the loss function). After the backpropagation comes the optimizer which computes updated parameters for the model. This is where training a neural net becomes more of an art than a science as there are so many possible optimizers and optimization settings (hyper-parameters).

Let’s represent our single training step in a more compact way

The training image is now a �� and the label indicating that the picture represents a cat is a ��. Large △s are our neural net with ■ parameters and gradients. The loss function is the L-box and the optimizer the O-box.

The learning process then simply consists in repeatedly applying the optimization step until we converge to good parameters for our neural net.

Let’s turn to meta-learning

The idea of meta-learning is to learn the learning process.

There are several ways to implement meta-learning [4] but the two I want to describe here are about learning a learning process that resemble the one we’ve just seen.

In our training process, there are two things in particular we can learn:

• the initial parameters of the neural net (blue ■) and
• the parametersof the optimizer (pink ★).

I will describe a combination of the two cases but each case is also very interesting on its own and can lead to simplifications, speedups and sound theoretical results [5].

So now, we have two modules to train:

• What I will call the model (M) which is our previous neural net. It can now be seen as a low-level network. It is sometimes called an optimizee or a learner. The weights of the model are the ■ on the drawings.
• The optimizer (O) or meta-learner is a higher-levelmodel which is updating the weights of the lower-level network (the model). The weights of the optimizer are the ★ on the drawings.

How do we learn these meta-parameters?

Well it turns out we can back-propagate a meta-loss gradient along the training process itself, back to the initial weights of the model and/or to the parameters of the optimizer [6].

We now have two, nested, training processes: the meta-training process of the optimizer/meta-learner in which the (meta-)forward pass includes several training steps of the model (with forward, backward and optimization steps as we saw previously).

Let’s take a look at the meta-training step:

Here, a single step of meta-training process is represented horizontally. It includes two steps of training process of the model (vertically in the meta-forward and meta-backward boxes). The training process of the model is exactly the same training process that we’ve just seen.

As we can see, the input of the meta-forward pass is a list of examples/labels (or a list of batches) that are used successively during the model training pass.

Now what meta-loss can we use to train the meta-learner? In the case of the model training we could simply compare the model prediction to the target label to get an error signal.

In the case of the meta-learner, we would like a meta-loss that is indicative of how well the meta-learner is performing its task: training the model.

One possibility is then to compute the loss of the model on some training data, the lower the loss, the better the training was. We can compute a meta-loss at the end or even just combine the losses of the model that we already compute during the training (e.g. by summing them).

We also need a meta-optimizer to update the weights of the optimizer. Here it starts to get very meta as we could use another meta-learner to optimize the meta-learner and so on, but in the end we will need a hand-defined optimizer like SGD or ADAM (it can’t be turtles all the way down).

There are a few important remarks regarding the implementation that we can as well discuss now:

• Second-order derivatives: back propagating the meta-loss through the model’s gradients involves computing derivatives of derivative, i.e. second derivatives (when the green ▲ passes through the green ■ on the meta-backward pass of our last animation). We can compute that in modern frameworks like Tensorflow or PyTorch but in practice we often drop the second derivatives and only back propagate though the model weights (the yellow ■ of the meta-backward pass) to reduce the complexity.
• Coordinate sharing: a recent deep-learning model can have a very large number of parameters (easily around 30–200 millions in NLP). With current GPU memory, it is not possible to have such a number of parameters as separate inputs to the optimizer. What we often do is called coordinate-sharing[7], it means we design the optimizer for a single parameter of the model and duplicate it for all parameters (i.e. share it’s weights along the input dimension associated to the model parameters). This way the number of parameters of the meta-learner is not a function of the number of parameters of the model. When the meta-learner is a network with a memory like an RNN, we can still allow to have a separate hidden state for each model parameters to keep separate memories of the evolution of each model parameter.

Meta-learning in PyTorch ��

Let’s try some code to see how this looks in practice.

So we have a model with a set of weights that we want to train and use for two tasks:

• during the meta-forward pass: we use our model to compute gradients (from the loss) that are feed as inputs to the optimizer to update the model parameters, and
• during the meta-backward pass: we use our model as a path for back propagating the gradients of the optimizer’s parameters (computed from the meta-loss).

The easiest way to do that in PyTorch is to have two duplicate modules that represent the model, one for each task. Let’s call forward model the module responsible for storing the model gradients used during the meta-forward pass and backward model the module responsible for keeping parameters as a continuous path for back propagating the optimizer gradients during the meta-backward pass.

The two modules will share their Tensors to avoid duplicating memory (tensors are the real meat in memory) but will keep separate Variables to cleanly separate the gradients of the model and the gradients used for the meta-learner.

A simple meta-learner class in PyTorch

Sharing Tensors in PyTorch is rather straight-forward: we just need to update the pointers in the Variable class to point to the same Tensors. One difficulty comes when our model is already a memory optimized model like an AWD-LSTM or AWD-QRNN model with shared Tensors (input and output embeddings). Then we need to be careful to keep the right pointers when we update the model parameters of the two modules.

One way to do that is to set a simple helper that will handle the task of looping through the parameters, send back all needed information to update the Parameters pointers (and not only the Tensors) and keep shared parameters synced. Here is such a function:

Using this function, we can plug any model and loop over the model parameters in our meta-learner in a clean way [8].

Now let’s draft a simple meta-learner class. Our optimizer is a module that will take as inputs during the forward pass, the forward model (with gradients) and the backward model, will loop over their parameters to update the backward model parameter in a way that allows meta-gradients to back propagate (by updating Parameters pointers and not only Tensors).

We can now train this optimizer as we saw in the first part. Here is a simple gist that illustrate the meta-training process that we have been describing:

Avoid memory blow-up — Hidden State Memorization

Sometimes we want to learn an optimizer that can operate on very large models with several tens of millions of parameters and at the same time we would like to unroll the meta-training over a large number of steps to get good quality gradients [9] like we did in our work.

In practice, it means we want to include a long training process during the meta-forward pass, with many time-steps, and we’ll have to keep in memory the parameters (yellow ■) and gradients (green ■) data for each step that are used for the meta-backward pass.

How can we do that without blowing up our GPU’s memory?

One way is to trade some memory for computation by using gradient checkpointing, also called hidden state memorization [10]. In our case gradient checkpointing consists in slicing the meta-forward and meta-backward passes in segments that we compute successively.

A good introduction to gradient checkpointing is given in the nice blog post of Yaroslav Bulatov of OpenAI. If you are interested in this, you should go and check it:

Fitting larger networks into memory.

TLDR; we release the python/Tensorflow package openai/gradient-checkpointing, that lets you fit 10x larger neural nets…

This post is already quite long so I won’t include a full gist of gradient checkpointing code. I’ll rather forward you to the nice PyTorch implementation of TSHadley and the current active work to include gradient checkpointing natively in PyTorch.

Other approaches in Meta-learning ��

There are two other trends of research in meta-learning that I hadn’t time to cover but which are also very promising. I’ll just give you a few pointers so you can go check that for your-self now that you know the general idea:

• Recurrent networks: We have built upon the standard training process of neural nets. An alternative is to consider the succession of task as a sequential series of input and build a recurrent model that can ingest and build a representation of this sequence for a new task. In this case we typically have a single training process with a recurrent network with memory or attention. This approach also gives good results, in particular when the embeddings are adequately designed for the task. A good example is the recent SNAIL paper.
• Reinforcement learning: The computation made by the optimizer during the meta-forward pass is very similar to the computation of a recurrent network: repeatedly apply the same parameters on a sequence of inputs (the succession of weights and gradients of the model during the learning). In practice this means we meet a usual issue with recurrent nets: the models have trouble returning to a safe path when they make errors as they are not trained to recover from training errors and the models have difficulties generalizing to longer sequences than the ones used during the meta-training. To tackle these issues, one can turn to reinforcement learning approaches where the model learn an action policy associated to a current state of training.

Meta-learning in Natural Language Processing ��

There is an interesting parallel between meta-learning and neural net models used in Natural Language Processing (NLP) like recurrent neural networks (RNN) that we have just started mentioning in the previous paragraph:

A meta-learner optimizing a neural net model behaves similarly to a recurrent neural network.

Like an RNN, the meta-learner ingests a series of parameters and gradients of the model during training, as an input sequence, and compute a sequential output (the series of updated model parameters) from this input sequence.

We develop this analogy in our paper and study how a meta-learner can be used to implement a medium-term memory in a neural net language model: the meta-learner learns to encode a medium-term memory in the weights of a standard RNN like a LSTM (in addition to the way short-term memories are conventionally encoded in the hidden state of the LSTM).

Our meta-learning language model has a hierarchy of memories with 3 levels, from bottom to top: a standard LSTM, a meta-learner updating the weights of the LSTM to store medium term memories and a long-term static memory.

We discovered that the meta-learning language model could be trained to encode memory of recent inputs, like the beginning of a Wikipedia article, that will be useful to predict the end of an article.

Well I guess now you are ready to have a look at our paper for more details on this story.

This concludes my introduction to Meta-Learning. Congratulation for reaching the end of this long post!

I hope you liked it!

Don’t forget to give us a few claps �� if you want more content like that!

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

Мета-обучение(англ. Meta-learning) — подход, позволяющий определять наиболее подходящий алгоритм (иногда, вместе с параметрами к нему) для конкретной задачи из портфолио алгоритмов. Основная идея мета-обучения — свести задачу выбора алгоритма к задаче обучения с учителем: задачи описываются мета-признаками. Мета-признак описывает свойство задачи — например, разрежен ли датасет или нет, число категориальных или численных признаков объектов в датасете, число возможных меток, размер датасета и многое другое.

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

Содержание

Обзор

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

\begin \theta^* = \arg\min_\theta \mathbb_<\mathcal\sim p(\mathcal)> [\mathcal_\theta(\mathcal)] \end

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

Ограничения — Теорема о том, что бесплатного завтрака не бывает(англ. No Free Lunch Theorem, сокр. NFL) theorem [1] [2] , доказанная в 1996 году.

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

Общая идея мета-обучения: для каждого набора данных $d \in \mathcal$ вычисляется вектор мета-признаков, которые описывают свойства этого набора данных. Ими могут быть: число категориальных или численных признаков объектов в $d$, число возможных меток, размер $d$ и многие другие [3] . Подробнее о конкретных метапризнаках смотреть ниже

Каждый алгоритм запускается на всех наборах данных из $\mathcal$. После этого вычисляется эмпирический риск, на основе которого формируются метки классов. Затем мета-классификатор обучается на полученных результатах. В качестве описания набора данных выступает вектор мета-признаков, а в качестве метки — алгоритм, оказавшийся самым эффективным с точки зрения заранее выбранной меры качества.

Каждый датасет $d \in \mathcal$ содержит пары признаков и меток, $\<(x_i, y_i)\>$, каждая метка принадлежит известному множеству меток $\mathcal$. Датасет $d$ делится на две части: $d=\langle S, B\rangle$, обучающую $S$ и тестовую $B$ выборки. Часто принимается k-shot N-class задача — обучающая выборка содержит $k$ размеченных примеров для каждого из $N$ классов. Скажем, наш классификатор $f_\theta$ с параметром $\theta$ показывает вероятность принадлежности точки из данных к классу $y$ при векторе признаков, $P_\theta(y|x)$. Оптимальные параметры должны максимизировать вероятность получения верных меток среди нескольких обучающих выборок $B⊂\mathcal$:

В пристрелочной (few-shot) классификации цель — уменьшить ошибку предсказания на неразмеченных данных. Чтобы его ускорить, сделаем следующее:

1. Возьмем подмножество меток, $T\subset\mathcal$
2. Возьмем обучающее множество $S^T⊂D$ и обучающую выборку $B^T⊂D$. Оба содержат только данные с метками из подмножества с пункта 1: $L, y \in L, \forall (x, y) \in S^T, B^T$
3. Множество $S^T$ подается на вход модели
4. Конечная оптимизация использует множество $B^T$, чтобы посчитать функцию потерь и обновить параметры модели через обратное распространение, так же, как это делается в обучении с учителем.

\begin \theta = \arg\max_\theta \color<\mathbb_>>[ \mathbb_<\color B \color<\sim T>> [\sum_ <(x, y) \in B>P_\theta(y \vert \mathbf \color<, S>)]] \end Красным цветом выделена разница между обучением с учителем и подходом мета-обучения.

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

Оптимизации методов Мета-обучения

LSTM-meta-learner

Оптимизационный алгоритм может быть явно смоделирован. Рави и Ларошель [4] это и сделали и назвали его «meta-learner». Цель meta-learner’а — эффективно обновлять свои параметры используя небольшую обучающую выборку так, чтобы learner мог быстро адаптироваться к новым задачам.

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

Обновление параметров learner’a во время $t$ со скоростью обучения $\alpha_t$ (шаг градиентного спуска):

\begin \theta_t = \theta_ — \alpha_t \nabla_<\theta_>\mathcal_t \end

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

\begin c_t = f_t \odot c_ + i_t \odot \tilde_t = \theta_ — \alpha_t\nabla_<\theta_>\mathcal_t \end

$c_t$ — параметры сети $\theta_t$, $\tilde_t = -\nabla_<\theta_>\mathcal_t$ при $f_t$ = 1.

$f_t$ = 1, $\tilde_t = -\nabla_<\theta_>\mathcal_t$ — не оптимальные значения, их изменение может оказаться полезным, если вы попали в неудачный локальный минимум.

\begin f_t &= \sigma(\mathbf_f \cdot [\nabla_<\theta_>\mathcal_t, \mathcal_t, \theta_, f_] + \mathbf_f) & \\ i_t &= \sigma(\mathbf_i \cdot [\nabla_<\theta_>\mathcal_t, \mathcal_t, \theta_, i_] + \mathbf_i) & \\ \tilde<\theta>_t &= -\nabla_<\theta_>\mathcal_t & \\ \theta_t &= f_t \odot \theta_ + i_t \odot \tilde<\theta>_t & \\ \end $f_t$ — как сильно мы забываем старые значения параметров на шаге $t$, $i_t$ — рейт обучения на шаге $t$.

REPTILE

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

1. Случайным образом разбиваем задачук на подмножества
2. тренируемся на ней несколькими шагами градиентного спуска
3. сдвигаем веса модели к новым параметрам.

$\text(\mathcal_<\tau_i>, \theta, k)$ выполняет стохастический градиентный спуск на $k$ шагов c функцией потерь $\mathcal_<\tau_i>$, начиная с параметра $\theta$ и возвращает конечный вектор параметров. Градиент reptile определяется как $(\theta — W)/\alpha$, где $\alpha$ — размер шага, используемый функцией $SGD$.

Определение множества конфигураций

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

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

Если мы хотим предоставить рекомендации для конкретной задачи $t_$, нам нужна дополнительная информация о том, насколько $t_$ похожа на предыдущие задачи $t_j$. Первый способ — посчитать число рекомендованных конфигураций для $t_$,получая новое докозательство $\mathbf

_$. Если позже мы будем наблюдать, что вычисления $P_$ соответствуют $P_$, то $t_$ и $t_$ могут быть очень похожими. Мы можем применить это знания для обучения meta-learner’a который предсказывает множество рекомендуемых конфигураций $\Theta^<*>_$ for $t_$. Более того, можно пойти дальше и добавить $\Theta^<*>_$ в $P_

Суррогатные модели

Более гибкий способ передать информацию — построить суррогатную модель $s_(\theta_) = P_$ для всех предшествующих задач $t_$, обученную с использованием всех доступных $\mathbf

$. Можно определить «похожесть» задач в терминах ошибок между $s_(\theta_)$ и $P_$: если суррогатная модель для $t_$ может генерировать точные предсказания для $t_$, тогда такие задачи весьма похожи. Обычно это делается в комбинации с Байесовской оптимизацией для определения следующей $\theta_$.

Так же можно обучать суррогатные модели на Гауссовских процессах (GP) для каждой предыдущей задачи и еще одну для $t_$ и объединить их во взвешенную и нормализованную сумму, с медианой $\mu$ определенной как взвешанная сумма $\mu_$ полученных из задач $t_$. Веса $\mu_$ считаются методом Надарая-Ватсона [5] , где каждая задача представлена вектором относительных ориентиров (англ. relative landmarks) или ядром Епанечникова [6] , используется для определения похожести между векторами относительных ориентиров для $t_$ и $t_$. Чем больше $t_$ похожа на $t_$, тем больше получится вес $s_$, увеличивающий влияние суррогатной модели для $t_$.

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

Обучение на свойствах задачи (learning on task properties)

Каждая задача $t_ \in T$ может быть описана вектором $m(t_j) = (m_, . m_)$ из $K$ мета-признаков $m_ \in M$,где $M$ — множество мета-признаков. Можно определить меру «похожести» задач, основанную, например, на Евклидовом расстоянии между $m(t_i)$ и $m(t_j)$, тогда можно будет использовать информацию из наиболее похожей задачи на новую задачу $t_$. Более того, используя предшествующие вычисления $\textbf

$ можно обучить meta-learner’a $L$ предсказывать производительность $P_$ конфигураций $\theta_$ на новых задачах $t_$.

$L: \Theta \times M \rightarrow \textbf

$

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

мета-признаки

Название	Формула	Объяснение	Варианты
простые
instances	$n$	Speed, Scalability [7]	$p/n$, $log(n)$, log(n/p)
features	$p$	Curse of dimensionality	$log(p)$, % categorical
classes	$c$	Complexity, imbalance	ratio min/maj class
Percent of missing values	$m$	Imputation effects [8]	% missing
outliers	$o$	Data noisiness [9]	$o/n$
статистические
Skewness	$\frac)^<3>><\sigma_^<3>>$	Feature normality	min,max,$\mu$,$\sigma$,$q_<1>,q_<3>$
Kurtosis	$\frac)^<4>><\sigma_^<4>>$	Feature normality	min,max,$\mu$,$\sigma$,$q_<1>,q_<3>$
Correlation	$\rho_X_<2>>$	Feature interdependence	min,max,$\mu$,$\sigma$,$\rho_$
Covariance	$cov_X_<2>>$	Feature interdependence	min,max,$\mu$,$\sigma$,$cov_$
Concentration	$\tau_X_<2>>$	Feature interdependence [10]	min,max,$\mu$,$\sigma$,$\tau_$
Sparsity	sparsity(X)	Degree of discreteness [11]	min,max,$\mu$,$\sigma$
Gravity	gravity(X)	Inter-class dispersion [12]
ANOVA p-value	$p__<1>X_<2>>>$	Feature redundancy	$p_>$
Coeff. of variation	$\frac<\sigma_><\mu_>$	Variation in target [13]
PCA $\rho_<\lambda_<1>>$	$\sqrt<\frac<\lambda_<1>><1+\lambda_<1>>>$	Variance in first PC	$\frac<\lambda_<1>> <\sum_\lambda_>$
PCA skewness	Skewness of first PC	PCA kurtosis
PCA 95\%	$\frac> $	Intrinsic dimensionality [14]
Class probability	$P(\texttt)$	Class distribution	min,max,$\mu$,$\sigma$
информационно-теоретические
Class entropy	$H(\texttt)$	Class imbalance
Norm. entropy	$\frac)>n>$	Feature informativeness [15]	min,max,$\mu$,$\sigma$
Mutual inform.	$MI(\texttt,\texttt)$	Feature importance	min,max,$\mu$,$\sigma$
Uncertainty coeff.	$\frac,\texttt)>)>$	[16]	min,max,$\mu$,$\sigma$
Equiv. nr. feats	$\frac<\overline>$	Intrinsic dimensionality
Noise-signal ratio	$\frac<\overline-\overline><\overline>$	Noisiness of data
сложностные
Fisher’s discrimin.	$\frac<(\mu_-\mu_)^<2>><\sigma_^<2>-\sigma_^<2>>$	Separability classes $c_<1>,c_<2>$
Volume of overlap	Class distribution overlap [17]
Concept variation	Task complexity [18]
Data consistency	Data quality [19]
основанные на модели
# nodes, leaves	[math]|\eta|,|\psi|[/math]	Concept complexity [20]	Tree depth
Branch length	Concept complexity	min,max,$\mu$,$\sigma$
Nodes per feature	[math]|\eta_|[/math]	Feature importance	min,max,$\mu$,$\sigma$
Leaves per class	[math]\frac<|\psi_|><|\psi|>[/math]	Class complexity [21]	min,max,$\mu$,$\sigma$
Leaves agreement	[math]\frac>>[/math]	Class separability [22]	min,max,$\mu$,$\sigma$
Information gain	Feature importance	min,max,$\mu$,$\sigma$, gini
ориентиры (landmarks)
Landmarker(1NN)	$P(\theta_<1NN>,t_)$	Data sparsity [23]
Landmarker(Tree)	$P(\theta_,t_)$	Data separability	Stump,RandomTree
Landmarker(Lin)	$P(\theta_,t_)$	Linear separability	Lin.Discriminant
Landmarker(NB)	$P(\theta_,t_)$	Feature independence	[24]
Relative LM	$P_ — P_$	Probing performance [25]
Subsample LM	$P(\theta_,t_,s_)$	Probing performance [26]

Непрерывные признаки $X$ и таргет $Y$ имеют медиану $\mu_$, стандартное отклонение $\sigma_$ и дисперсию $\sigma^<2>_$. Категориальные признаки $\texttt$ и класс $\texttt$ имеют категориальные значения $\pi_$, условные вероятности $\pi_$, совместные вероятности $\pi_$, предельные вероятности $\pi_=\sum_\pi_$ и энтропию $H(\texttt)=-\sum_\pi_log_<2>(\pi_)$.

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

Во время вычисления похожести задач важно нормализовать все мета-признаки, использовать отбор признаков [27] или использовать уменьшение размерности (например, principal component analisys — PCA).

Ориентиры (англ. landmarks)

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

Относительные ориентиры

Первая мера для вычисления «похожести» задач вычисляла попарно разницу в производительности, так же называемую «relative landmarks» $RL_ = P_ — P_$ между двумя конфигурациями $\theta_$ и $\theta_$ на конкретной задаче $t_$.

Линейный дискриминант

Линейный дискриминант (англ. linear discriminant) $P(\theta_,t_)$ можно понимать как группировка и разделение категорий соответствующих конкретным признакам. Линейный дискриминант обычно ищет линейную комбинацию признаков, которая лучше всего разделит классы. Результат — линия, плоскость или гиперплоскость, зависит от числа комбинированных признаков.

Наивный Байесовский лэндмарк

Наивный Байесовский лэндмарк $P(\theta_,t_)$ [28] — вероятностный классификатор, основанный на теореме Байеса. Называется наивным потому что предполагается, что все атрибуты независимы друг от друга.

Elite 1-nearest neighbor $P(\theta_<1NN>,t_)$ [29] kNN c $k = 1$. Elite — вариация основного метода, но в этом случае на вход kNN подается предварительно отобранное множество самых информативных примеров (у них минимлаьная разница приращения информации (information gain).Помогает установить, является ли задача релевантной, если похожи их атрибуты.

Похожие публикации:

1. Как удалить steam ubuntu
2. Что означает архитектура процессора типа cisc
3. Как построить маршрут чтобы роботу хватило энергии
4. Gimp как убрать выделение