Le Méta-learning est une généralisation du machine learning

Plutôt que de résoudre n’importe quel problème à la perfection, le méta-learning cherche à améliorer le processusd’apprentissage en lui-même. C’est attirant, d’un point de vue des sciences cognitives : les humains ont besoin de beaucoup moins d’exemples qu’un deep net pour comprendre un pattern, et on peut souvent apprendre de nouvelles capacités et former de nouvelles habitudes plus rapidement si on est plus conscient de vouloir atteindre volontairement un certain but.

Une plus grande précision avec moins d’exemples

Dans le deep learning classique, nous appliquons une gradient descent sur des exemples d’entraînement pour apprendre les meilleurs paramètres pour une tâche en particulier (comme classer une photo d’un animal parmi une des 5 espèces possibles). Dans le méta-learning, la tâche en elle-même devient un exemple d’entraînement : nous appliquons un algorithme d’apprentissage sur de nombreuses tâches pour apprendre quels sont les meilleurs paramètres pour un type particulier de problème (e.g. la classification de photos dans N classes). Dans Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks(Méta-Learning Agnostique en Modèle pour une Adaptation Rapide des Réseaux Profonds) de ICML 2017, l’algorithme de méta-learning est, de manière élégante, une gradient descent, et elle fonctionne pour tout type d’inner model qui est lui-même entraîné avec une gradient descent (d’où "Agnostique en Modèle"). Finn, Abbeel, et Levine ont appliqué ceci aux problèmes d’apprentissage en classification, en régression et en renforcement et ont paramétré un méta-modèle (l’outer model) qui peut apprendre rapidement (1-10 updates de gradients) sur une nouvelle tâche avec seulement quelques exemples (1-5 par classe pour 2-20 classes). En pratique, est-ce que ça fonctionne vraiment aussi bien, et comment pouvons nous appliquer ce méta-modèle au mieux à de nouveaux datasets ?

Classification Few-shot sur mini-ImageNet (MIN)

Dans ce rapport, je me concentre sur MAML pour la classification d’image few-shot, en instrumentant le code original pour le papier. Ci-dessous, quelques exemples du dataset Mini-ImageNet (MIN) avec mes meilleures idées quant aux labels (qui pourraient être en fait être des catégories plus spécifiques ou plus générales). Ceci est plutôt représentatif d’ImageNet : une diversité d’images et de points de vue sur un objet cible, équilibré avec des cadrages centrés et strict, avec des définitions qui ne sont pas toujours intuitives (e.g. les classes "wolf" (loup) et "bird" (oiseau) pourraient être réduites à une espèce particulière).

Classification d’images N-way, K-shot

Tiré du papier MAML : "D’après la terminologie conventionnelle, les tâches de classification k-shot utilisent K paires d’input/output de chaque classe, pour un total de NK points de données pour une classification N-way."

Voici les paramètres pertinents (les arguments flags) dans le code fourni :

• num_classes : N, comme dans classification N-way, est le nombre de différentes classes d’images qu’on apprend à chaque étape
• update_batch_size: K, comme dans apprentissage K-shot, est le nombre d’exemples vus pour que chaque classe update l’inner gradient sur un modèle spécifique à une tâche

Donc, 5-way, 1-shot MIN considère 1 image libellée de chacune des 5 classes (un total de 5 images). 5-way, 5-shot MIN considère 5 images libellées de chacune des 5 classes (un total de 25 images). Des exemples de scénarios sont montrés plus bas. Notez comment la diversité des classes dans une tâche à N-way donnée peut varier : e.g. des espèces différentes de chiens qui se ressemblent ou le panel de visuels utilisés pour représenter "lipstick" (rouge à lèvres) pourraient être beaucoup plus compliqués à apprendre.

Autres flags importants pour les dynamiques d’entraînement

• meta_batch_size est le nombre de tâches échantillonnées avant que l’on update les méta-paramètres de l’outer modèle/de la boucle de méta-training
• num_updates est le nombre de fois que l’on update l’inner gradient/l’inner modèle pendant l’entraînement
• metatrain_iterations est le nombre total de tâches d’exemples que le modèle voit. Le code recommande 60 000 pour MIN ; j’ai fini par passer sur les 15 000 par défaut pour des raisons d’efficacité
• Paramétrer l’effective batch size (taille de lot effective) sur 8 plutôt que 16 fournit des performances comparables pour un entraînement beaucoup plus rapide.

Observations initiales

Ici, je compare les runs de meta-learning avec K=1 shot d’apprentissage (1 exemple pour chaque classe), en variant le nombre de classes (num_classes), le nombre d’updates d’inner gradients (num_updates), l’effective batch size, et le nombre de filtres appris. Tous les graphiques sont montrés avec un lissage 0.8.

• Un N plus bas est plus simple : intuitivement, moins il y a de classes à distinguer, meilleures sont les performances du modèle. Vous pouvez constater qu’à travers les graphiques, la précision en rouge (2-way) est plus haute que celle en orange (3-way) ou que les bleues (5-way).
• Le nombre d’update d’inner gradient au-delà de 5 n’a pas beaucoup d’importance : la précision post-update à l’étape 10 ne change pas tellement de celle à l’étape 5 (référez-vous à la première ligne, graphique de droite, où les courbes libellées pour l’étape 5 et l’étape 10 se recoupent presque entièrement)
• Une effective batch size plus basse entraîne plus rapidement, et légèrement moins bien : le code original ajoute mystérieusement 15 à la batch size (taille de lots). Défaire ceci et paramétrer une effective batch size de 4 ne fait que légèrement dégrader les performances, et paraît plus logique avec K. L’effective batch size, selon les définitions traditionnelles du méta-learning, devrait être N K, pas N (K+15).
• Doubler le nombre de filtres augmente légèrement les performances : comme on pouvait s’y attendre avec plus de learning capacity ; comparez le run en bleu moyen avec 64 filtres (suffixe "fs64") à celui en bleu clair et aux runs en bleu foncé, qui ont 32 filtres.

Utiliser trois repos et un gis

• Les véritables images sont disponibles depuis un autre repo : few-shot-ssl-public en format .pkl. Ce repo étend la classification few-shot à l’apprentissage depuis des exemples sans labels, avec des tâches plus complexes de classes distractor (jusque-là, jamais vues) Meta-Learning for Semi-Supervised Few-Shot Classification (Le Méta-Learning pour la Classification semi-supervisée few-shot), Ren et al, ICLR 2018).
• J’ai écrit ce gist pour extraire les images et les préparer à l’entraînement dans MAML. Cela accélère grandement le processus d’extraction de données, parce qu’il sauvegarde directement chaque fichier d’image directement au bon endroit, plutôt que de déplacer des fichiers avec une commande Python os.system("mv...").

Setup de training data

Pour mini-ImageNet (MIN), les données sont séparées en train (64 classes), en validation (16 classes) et en test (20 classes). Chaque classe contient 600 images, de 84x84 pixels. data_generator.py dans le repo principal choisit aléatoirement les classes, et prend aléatoirement le bon nombre de samples par classe (K en K-shot learning), du bon split, en fonction du mode (entraînement, validation ou test). Un détail qui peut prêter à confusion, c’est que le code source incrémente l’inner batch size K de 15 lorsqu’il génère la training data, ce qui peut affecter l’exactitude de l’image shuffling. J’ai fait des entraînements avec et sans cette modification pour essayer d’isoler son impact et sa nécessité.

Expériences suivantes

• Fixer N, varier K : comment est-ce que ça affecte la précision ?
• Entraînement sur omniglot : comment les dynamiques sont-elles similaires/différentes dans la classification de caractères en comparaison avec des images naturelles ?
• Mélanger régression et classification, et potentiellement RL : est-ce qu’on peut entraîner sur Omniglot et peaufiner sur MIN, et vice-versa ? Y-a-t-il un modèle général qui pourrait apprendre sur les trois types de problèmes ?
• Hyperparamètres de Méta-training : je n’ai pas exploré de nombreux hyperparamètres de la boucle de méta-training.
• Précisions de tests & Méta-tests sur des nombres d’updates de Méta-training : Explorer la précision de test et celle de méta-test de ces modèles entraînés – comment est-ce que c’est corrélé avec la précision metaval ? Comment le nombre d’updates de Méta-training affecte ce résultat ? Pour de meilleurs résultats sur un dataset d’image entièrement nouveau, choisir le modèle avec la plus haute précision de méta-test.
• Dynamiques pré-update et post-update : Comment pouvons-nous intuitivement comprendre les mesures pré-update ? À quel point le nombre d’étapes d’updates de méta-training est-il important (varier meta_batch_size) ? Est-il logique de comparer le changement de loss à travers les updates ?
• Dynamiques inner gradients : pourquoi l’inner validation sature de chances aléatoires, dans de nombreux cas ? Pourquoi est-ce que la moyenne postloss est plus haute que la moyenne préloss ?

Limites

• Certaines configurations d’entraînement rencontrent des limites de mémoire : par exemple, les erreurs de classification 10-way, 10-shot sont comme suit :

File "/home/stacey/.pyenv/versions/mm/lib/python3.7/site-packages/tensorflow/python/framework/ops.py", line 1950, in __init__
    "Cannot create a tensor proto whose content is larger than 2GB.")

• Par défaut, K est 5, et il contrôle apparemment l’update_batch_size / le nombre d’exemples que l’ont voit pour chaque classe dans l’inner loop. Néanmoins, le code original lui ajoute 15 pour générer des données MIN, supposément pour "utiliser 15 exemples val pour imagenet" d’après un commentaire/TODO. Plus tard dans le code, la training data est générée avec tf.slice() et l’update_batch_size correcte, non-modifiée, mais je ne suis pas certaine que cela préserve bien le classement intriqué de la training data par classe…