[PYTHON] Réglage fin BigTransfer (BiT)

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

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

Nom du modèle base de données
BiT-S ILSVRC-2012 (1.3M images)
BiT-M ImageNet-21k (14M images)
BiT-L JFT (300M images)
ResNet Nombre de paramètres (nombre approximatif)
R50x1 23M
R101x1 42M
R50x3 211M
R101x3 381M
R152x4 928M

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. BigTransfer (BiT): State-of-the-art transfer learning for computer vision; 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)

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

Cité du blog officiel Tableau 2. BigTransfer (BiT): State-of-the-art transfer learning for computer vision; Table2

«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]. MixUp Cat-Dog

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

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)

prime

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

Recommended Posts

Réglage fin BigTransfer (BiT)
Divers réglages fins avec Mobilenet v2
[Kaggle] Classifier le cancer du côlon [réglage fin]
[PyTorch] CPU vs GPU vs TPU [Réglage fin]
J'ai essayé le réglage fin de CNN avec Resnet