Durch die Implementierung der Methode mit TF 2.x ist er eine Person, die in Flammen steht. Es ist ungefähr ein Jahr her, seit TF 2.x herauskam, aber ich werde zusammenfassen, was TF 2.x getan hat, was es nicht getan hat und welche Methoden kürzlich ans Licht gekommen sind.
Kannst du das tun? Ist das nicht falsch? Wenn es so etwas gibt, weisen Sie bitte darauf hin und korrigieren Sie es. In Zukunft werden diejenigen gerettet, die unter diesem verdammten Rahmen leiden.
Mit der Hinzufügung von Eager Execution wurde tf.session veraltet und der Interpreter kann nun tf-Funktionen ausführen. Dies erleichterte das Debuggen und das Ausführen.
Aufgrund des Integrationsflusses mit Keras wurde auch eine Implementierung mit tf.keras.layer ( nn.Module? In PyTorch) gefördert. Andererseits werden vorhandene funktionale Implementierungen jetzt unter "tf.nn" zusammengefasst, beispielsweise ist "BatchNormalization" "tf.nn.batch_normalization".
Es scheint, dass die Verwendung von TPU immer bequemer wird. Artikel hier ist sehr einfach zu lesen, also lesen Sie es bitte.
~~BatchNormalization~~ Sie denken vielleicht, dass eine Chargennormalisierung nicht möglich ist, aber unerwartet hat diese Ebene viele Lücken und es ist schwierig, eine richtige Implementierung zu finden (ich frage mich, ob es noch keine richtige Implementierung gibt ...)
Das Problem ist, dass ** Operationen mit mehreren GPUs / TPUs ** nicht verarbeiten kann, und dies ist PyTorch. #syncbatchnorm) und MxNet wurden implementiert, TF 2.x wurde jedoch noch nicht implementiert. Die Zeit, als ich mich für MultiGPU / TPU (TF 1.x-Serie) auf horovod verlassen habe, wurde durch die Unterstützung dieser Person realisiert, aber als Ergebnis des Versuchs, es in TF verschoben zu implementieren. //github.com/tensorflow/community/blob/master/rfcs/20181016-replicator.md#global-batch-normalization).
Dieses Problem scheint in der gesamten TF 2.x-Familie ärgerlich zu sein (da viele Forscher nach PyTorch fliehen) (https://github.com/tensorflow/tensorflow/issues/7439). ) Es ist ein hartes Problem.
Die neueste Ausgabe, die derzeit geöffnet ist, ist wahrscheinlich hier. Bitte schließen Sie sich uns an (ich grabe auch selbst).
--2020 / 2/3 Die Ebene selbst wurde hinzugefügt. Es ist jedoch zweifelhaft, ob es getestet wurde. Erwarten Sie also nicht zu viel.
TF 2.x kann vorerst mit mehreren GPUs / TPUs rechnen! Die Realität ist jedoch, dass es voller experimenteller Unterstützung ist, wie Sie in Official sehen können. Daher besteht eine hohe Wahrscheinlichkeit, dass sich die Rollfunktion ändert, und es ist schwierig, eine Abwärtskompatibilität zu erwarten.
Die Initialisierung mit anfänglichen Batch-Daten, die beim Deep Learning selten verwendet wird, kann nicht durchgeführt werden, solange dies ebenfalls beobachtet wird. Der Weg, dies zu tun, besteht darin, die Schichtgewichte direkt von außen entsprechend der anfänglichen Charge neu zu schreiben, was das Entwerfen einer externen Funktion zum Initialisieren und eines Mechanismus zum Aufrufen dieser externen Funktion während des Trainings erfordert. Dies macht es schwierig, die üblichen "tf.keras.Model" und "tf.keras.Sequential" zu verwenden (mindestens "fit ()" kann nicht verwendet werden und muss in einer benutzerdefinierten Trainingsschleife trainiert werden). (Beispiel)
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
In 2.0.0 scheint die Gradientenberechnung in einem speziellen Fall Unfall zu sein. (Ich fand es vernünftig, aber es scheint passend zu sein)
Aber 2.1.0 Wurde repariert. (Ich habe es auch zur Hand getestet, aber es wurde behoben.)
Es wird selten verwendet, wenn ein sehr langer Satz in Python geschrieben wird, aber Tensorflow scheint den Syntaxanalysebaum (?) Von Python nicht zu verwenden. Daher kann dieser nicht verwendet werden. https://github.com/tensorflow/tensorflow/issues/35765
Schlechtes Beispiel
variable * decay * \
lr
Gutes Beispiel
(variable * decay *
lr)
Die Unterstützung für Python 3.8 scheint Mitte 2020/02 zu beginnen. (Es scheint, dass Sie es versuchen können, indem Sie einen Quell-Build durchführen)
https://github.com/tensorflow/tensorflow/issues/33374
Ich habe dies kürzlich bemerkt, daher weiß ich nicht alles, aber anscheinend die offiziellen einige Implementierungen. In Bezug auf transformer_main.py) wird empfohlen, eine Klasse für Training und Inferenz getrennt von der Modellklasse zu erstellen.
Grundsätzlich sind die zu implementierenden Funktionen Training, Test train,test (eval)und xxx_step, und für xxx_step ist es eine Funktion, die einen Stapel und tf.function Dekorator verarbeitet. Das von umgebene Muster wird oft gesehen.
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):
...
Ich schreibe eine Tensorflow-Klasse. Was ist das für ein Argument? Ich dachte, aber dies ist ein wichtigeres Argument als ich erwartet hatte, und es ist sehr nützlich, wenn Sie beispielsweise die Argumentation / das Training der BatchNormalization-Ebene und der Dropout-Ebene wechseln.
Zum Beispiel
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 kann im Inferenzmodus ausgeführt werden, indem "cl (x, training = False)" gesetzt wird.