[PYTHON] Réglage fin BigTransfer (BiT)

--Blog officiel https://blog.tensorflow.org/2020/05/bigtransfer-bit-state-of-art-transfer-learning-computer-vision.html

• Exemple de code officiel (TF2, PyTorch, JAX) https://github.com/google-research/big_transfer/tree/master/colabs

De là, les informations nécessaires pour le réglage fin de BiT (l'endroit que j'ai utilisé / examiné lorsque j'ai joué) sont extraites et résumées en japonais.

Texte

• ** URL où vous pouvez vous référer et obtenir le modèle pré-formé ** Les formats h5 et npz sont stockés dans le bucket Cloud. Il peut être utilisé autrement que TF.

• TensorFlow Hub
  https://tfhub.dev/google/collections/bit/1

• Cloud bucket
  https://storage.googleapis.com/bit_models/

• La signification de ** S, M, L ** attaché au modèle BiT ⇒ Différences dans les ensembles de données formés. ** L ** est privé.

• La signification de ** R- ?? x? ** sur le modèle BiT Le modèle BiT utilise ResNet, donc les informations qu'il contient. --Comment lire R50x3 → 50 couches de ResNet, la largeur de chaque couche est 3 fois la largeur normale. --Nombre de paramètres Affiche le nombre approximatif de paramètres du modèle publié sur TFHub (à l'exclusion de la couche de sortie).

Le code suivant confirme le nombre de paramètres.

import tensorflow as tf
import tensorflow_hub as tfhub
model = tfhub.KerasLayer('https://tfhub.dev/google/bit/s-r50x1/1')
print(sum(tf.math.reduce_prod(w.shape).numpy() for w in model.weights))

BiT-HyperRule

Une méthode heuristique fournie pour affiner BiT. "Si vous utilisez ceci, vous vous sentirez bien en un seul coup."

Bien sûr, une recherche Hyper-paramètre peut vous donner un meilleur modèle. Cela vaut le coût.

Dépend de la taille de l'image du jeu de données → Redimensionner, taille du recadrage

Redimensionner et recadrer aléatoirement à la taille spécifiée avec la taille d'image de l'ensemble de données. Le tableau de correspondance est tiré du blog officiel Table1. En même temps, insérez l'inversion gauche et droite au hasard. Il vous suffit de redimensionner les données de validation.

Je me demande si TF2 aura une telle ambiance.

def augmentation(image, label):
    image = tf.cast(image, tf.float32) / 255.0
    image = tf.image.resize(image, [512, 512], method=tf.image.ResizeMethod.BILINEAR)
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_crop(image, [480, 480, 3])
    return image, label

ds_train: tf.data.Dataset
ds_train = (ds_train
            .shuffle(1024)
            .repeat()
            .map(augmentation, tf.data.experimental.AUTOTUNE)
            .batch(64)
            .prefetch(tf.data.experimental.AUTOTUNE))

Note

――Je pense que la taille de l'image peut être clairsemée ... ―― J'ai lu le code source public, mais il a été redimensionné uniformément, vous n'avez donc pas à vous en soucier. ――Si vous ne vous inquiétez que d'une partie, filtrez-la. (J'ai essayé de le supprimer dans l'échantillon bonus)

• Expansion des données qui n'est pas effectuée en fonction de la tâche car elle sera différente de l'étiquette de réponse correcte. --Compte des objets ⇒ Le recadrage aléatoire est NG --Spécifiez la position de l'objet ⇒ Le retournement aléatoire est NG

Dépend du nombre d'échantillons de jeux de données → Nombre d'étapes d'apprentissage, Mix-Up

Cité du blog officiel Tableau 2.

«limites» est utilisé pour la planification ultérieure de la vitesse d'apprentissage.

if dataset_size < 20 * 10 ** 3:
    schedule_len, boundaries = 500, [200, 300, 400]
elif 20 * 10 ** 3 <= dataset_size < 500 * 10 ** 3:
    schedule_len, boundaries = 10000, [3000, 6000, 9000]
else:
    schedule_len, boundaries = 20000, [6000, 12000, 18000]

Comment mélanger

Référence: https://github.com/google-research/big_transfer/blob/master/input_pipeline_tf2_or_jax.py#L118

import tensorflow_probability as tfp

def mixup(image, label):
    beta_dist = tfp.distributions.Beta(0.1, 0.1)  # alpha=0.1
    beta = tf.cast(beta_dist.sample([]), tf.float32)
    image = (beta * image + (1 - beta) * tf.reverse(image, axis=[0]))
    label = (beta * label + (1 - beta) * tf.reverse(label, axis=[0]))
    return image, label

Modifiez les arguments selon vos besoins. Pour cette fonction, le timing pour s'adapter à l'ensemble de données est ** après le mini-batch batch () **.

Puisque MixUp est impliqué, l'étiquette doit être un vecteur One-Hot.

En passant, le code ci-dessus est mélangé par tf.reverse avec un ensemble de données situé symétriquement du centre du lot. Voici un exemple de 16 lots. Il est mélangé en haut à gauche [0] et en bas à droite [15].

Taille du lot = 512

Si la mémoire n'est pas possible, vous pouvez la réduire.

Dans l'exemple de code TF2, le taux d'apprentissage et le nombre d'étapes sont ajustés en fonction de la taille du lot. ・ ・ Mais cela n'est pas fait dans d'autres échantillons. Je n'ai pas changé le nombre d'étapes lors de la modification du taux d'apprentissage, mais je ne sais pas pourquoi.

batch_size = 64
schedule_len = schedule_len * 512 / batch_size
lr = 0.003 * batch_size / 512

Algorithme d'optimisation = SGD

• Learning rate: 0.003
• Momentum: 0.9

Le taux d'apprentissage est la valeur initiale. La planification suivante est effectuée pour modifier le taux d'apprentissage pendant l'apprentissage.

Planification du taux d'apprentissage

Lorsque la progression de l'apprentissage atteint 30%, 60%, 90% du total, le taux d'apprentissage est atténué de $ \ frac {1} {10} $.

Dans l'exemple de code officiel, il n'est pas strictement séparé par 30%, 60%, 90%. Par exemple, lorsque le nombre d'échantillons est inférieur à 20k, il devient 0,003 jusqu'à 200 pas et 0,0003 entre 201 et 300 pas.

lr_schedule = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
    boundaries=boundaries, values=[lr, lr * 1e-1, lr * 1e-2, lr * 1e-3])

optimizer = tf.keras.optimizers.SGD(learning_rate=lr_schedule, momentum=0.9)

• Dans l'exemple de code TF2, il ne s'agit pas de toutes les valeurs = [lr, lr * 0,1, lr * 0,001, lr * 0,0001] et $ \ frac {1} {10} $. Dans la version PyTorch, il est progressivement atténué. Je ne sais pas si c'est dare ou typo.

prime

Jupyter Notebook lors de la lecture avec Cats vs Dogs affiné en référence à l'exemple de code.