Suite à la mise en œuvre de la méthode avec TF 2.x, il est une personne en feu. Cela fait environ un an que TF 2.x est sorti, mais je vais résumer ce que TF 2.x a fait, ce qu'il n'a pas fait et les méthodes qui ont récemment vu le jour.
Pouvez-vous faire cela? N'est-ce pas faux? S'il y a quelque chose comme ça, veuillez le signaler et le corriger. À l'avenir, ceux qui souffrent de ce ~~ putain de ~~ framework seront sauvés.
Avec l'ajout d'Eager Execution, tf.session est devenu obsolète et l'interpréteur peut désormais exécuter des fonctions tf. Cela a rendu le débogage plus facile et plus facile à exécuter.
De plus, en raison du flux d'intégration avec keras, une implémentation utilisant tf.keras.layer ( nn.Module? Dans PyTorch) a été promue. D'autre part, les implémentations fonctionnelles existantes sont maintenant agrégées sous «tf.nn», par exemple BatchNormalization est «tf.nn.batch_normalization».
Il semble que l'utilisation du TPU soit de plus en plus pratique. Articles par ici est très facile à lire, alors veuillez le lire.
~~BatchNormalization~~ Vous pensez peut-être que la normalisation par lots n'est pas possible, mais de manière inattendue, cette couche comporte de nombreux trous et il est difficile de trouver une implémentation correcte (je me demande s'il n'y a pas encore d'implémentation correcte ...)
Le problème est que ** ne peut pas gérer les opérations avec plusieurs GPU / TPU **, et c'est PyTorch. #syncbatchnorm) et MxNet ont été implémentés, mais TF 2.x n'a pas encore été implémenté. Le moment où je me suis appuyé sur horovod pour MultiGPU / TPU (série TF 1.x) a été réalisé grâce au soutien de cette personne, mais à la suite d'essayer de l'implémenter à l'intérieur de TF reporté //github.com/tensorflow/community/blob/master/rfcs/20181016-replicator.md#global-batch-normalization).
Ce problème semble ennuyeux dans toute la famille TF 2.x, car de nombreux chercheurs s'échappent vers PyTorch. ) C'est un problème difficile.
Le dernier numéro actuellement ouvert est probablement ici alors rejoignez-nous (je me fouille aussi).
--2020 / 2/3 La couche elle-même a été ajoutée. Cependant, il est douteux qu'il ait été testé, alors ne vous attendez pas à trop.
Pour le moment, TF 2.x peut calculer avec plusieurs GPU / TPU! Cela dit, la réalité est qu'il est plein de support expérimental, comme indiqué dans Officiel. Par conséquent, il y a une forte possibilité que la fonction de roulement change, et il est difficile de s'attendre à une compatibilité ascendante.
L'initialisation avec les données de lots initiales, qui est rarement utilisée dans l'apprentissage en profondeur, ne peut pas être effectuée tant que cela est également observé. La méthode consiste à réécrire le poids de la couche directement de l'extérieur en fonction du lot initial, ce qui nécessite de concevoir une fonction externe à initialiser et un mécanisme pour appeler cette fonction externe pendant la formation. Cela rend difficile l'utilisation des habituels «tf.keras.Model» et «tf.keras.Sequential» (au moins «fit ()» ne peut pas être utilisé et doit être entraîné dans une boucle d'entraînement personnalisée). (Exemple)
class IdentityWithInit:
def build(self, input_shape: tf.TensorShape):
self.initialized = self.add_weight(
name="initialized",
dytpe=tf.bool,
trainable=False
)
self.initialized.assign(False)
self.built = True
def initialize_parameter(self, x: tf.Tensor):
tf.print("initialized {}".format(self.name))
pass
def __init__(self):
super()__init__()
def call(self, x:tf.Tensor):
if not self.initialized:
self.initialize_parameter(x)
self.initialized.assign(True)
return x
En 2.0.0, le calcul du gradient semble accidentel dans un cas particulier. (Je pensais que c'était sain d'esprit, mais cela semble être approprié)
Mais 2.1.0 A été réparé. (Je l'ai également testé à portée de main, mais il a été corrigé.)
Il est rarement utilisé lors de l'écriture d'une très longue phrase en Python, mais Tensorflow ne semble pas utiliser l'arbre d'analyse de syntaxe de Python (?), Donc cela ne peut pas être utilisé. https://github.com/tensorflow/tensorflow/issues/35765
Mauvais exemple
variable * decay * \
lr
Bon exemple
(variable * decay *
lr)
La prise en charge de Python 3.8 semble commencer à la mi-2020/02. (Il semble que vous puissiez l'essayer en faisant une compilation source)
https://github.com/tensorflow/tensorflow/issues/33374
J'ai remarqué cela récemment, donc je ne sais pas tout, mais apparemment les [quelques implémentations] officielles (https://github.com/tensorflow/models/blob/master/official/transformer/v2/ En ce qui concerne transformer_main.py), il semble recommandé de créer une classe pour l'apprentissage et l'inférence séparément de la classe modèle.
Fondamentalement, les fonctions à implémenter sont la formation, le test train, test (eval) ʻet xxx_step, et pour xxx_step, c'est une fonction qui traite un lot et un décorateur tf.function`. Le motif entouré par est souvent vu.
class MyTask:
def __init__(self, args):
...
self.loss = tf.metrics.Mean(name='loss', dtype=tf.float32)
def train(self):
@tf.function
def train_step(x: tf.Tensor, y: tf.Tensor):
...
_y = self.model(x)
loss = loss_fn(_y, y)
self.loss(loss)
for epoch in range(self.epochs):
for x, y in tqdm(self.train_dataset):
train_step(x, y)
for x, y in self.val_dataset:
val_step(x, y)
print('EPOCH {} train: loss {} / val: loss {}'.format(epoch + 1,
self.loss.result(), self.val_loss.result()))
self.loss.reset_states()
self.val_loss.reset_states()
def test(self):
@tf.function
def test_step(x: tf.Tensor, y: tf.Tensor):
...
J'écris une classe Tensorflow Quel est cet argument? J'ai pensé, mais c'est un argument plus important que ce à quoi je m'attendais, et il est très utile lors du changement de raisonnement / apprentissage de la couche BatchNormalization et de la couche Dropout, par exemple.
Par exemple
class CustomLayer(Layer):
def __init__(self):
self.conv = Conv2D(...)
self.bn = BatchNormalization(...)
super().__init__()
def build(self, input_shape):
super().build(input_shape)
def call(self, x: tf.Tensor, **kwargs):
y = self.conv(x, **kwargs)
y = self.bn(y, **kwargs)
cl = CustomLayer()
BatchNormalization peut être exécuté en mode inférence en définissant cl (x, training = False).
Recommended Posts