Verhoog de TensorFlow-trainingssnelheid met 50% met deze TPU-tricks

Content Overzicht instellen TPU initialisatie' Handmatige plaatsing apparaat Verdelingsstrategieën Classificatie op TPU's Definieer een Keras-model Laden van de dataset Train het model met behulp van Keras high-level API's Train het model met behulp van een custom training loop Verbetering van de prestaties met meerdere stappen binnen tf.function Volgende stappen Deze gids laat zien hoe je basisopleidingen kunt uitvoeren op en TPU Pods, een verzameling TPU-apparaten die zijn verbonden door speciale high-speed netwerkinterfaces, met en custom training loops. De Tensor Processing Units (TPU’s) tf.keras TPU's zijn Google's op maat ontwikkelde applicatie-specifieke geïntegreerde circuits (ASIC's) die worden gebruikt om werkloads voor machine learning te versnellen. De en . Google Colab TPU Onderzoek Cloud De cloud TPU instellen Voordat u deze Colab-notebook uitvoert, moet u ervoor zorgen dat uw hardware-accelerator een TPU is door de instellingen van uw notebook te controleren: > > > > > > . Runtime Change runtime type Hardware accelerator TPU Importeer enkele noodzakelijke bibliotheken, waaronder TensorFlow-datasets: import tensorflow as tf import os import tensorflow_datasets as tfds 2023-06-09 12:13:32.486552: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT TPU initialisatie TPU's zijn typisch werknemers, die verschillen van het lokale proces dat het Python-programma van de gebruiker draait. Zo moet je wat initialisatiewerk doen om verbinding te maken met de externe cluster en de TPU's te initialiseren. Argument voor Als u uw code op Google Compute Engine (GCE) uitvoert, moet u in plaats daarvan de naam van uw Cloud TPU doorgeven. De cloud TPU tpu tf.distribute.cluster_resolver.TPUClusterResolver Opmerking: De TPU-initialisatiecode moet aan het begin van uw programma staan. De TPU-initialisatiecode moet aan het begin van uw programma staan. Note: resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='') tf.config.experimental_connect_to_cluster(resolver) # This is the TPU initialization code that has to be at the beginning. tf.tpu.experimental.initialize_tpu_system(resolver) print("All devices: ", tf.config.list_logical_devices('TPU')) INFO:tensorflow:Deallocate tpu buffers before initializing tpu system. 2023-06-09 12:13:34.011755: E tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:266] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected INFO:tensorflow:Deallocate tpu buffers before initializing tpu system. INFO:tensorflow:Initializing the TPU system: grpc://10.25.167.66:8470 INFO:tensorflow:Initializing the TPU system: grpc://10.25.167.66:8470 INFO:tensorflow:Finished initializing TPU system. INFO:tensorflow:Finished initializing TPU system. All devices: [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')] Handmatige plaatsing apparaat Nadat de TPU is geïnitieerd, kunt u met behulp van handmatige apparaatpositie de berekening op een enkel TPU-apparaat plaatsen: a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) b = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) with tf.device('/TPU:0'): c = tf.matmul(a, b) print("c device: ", c.device) print(c) c device: /job:worker/replica:0/task:0/device:TPU:0 tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32) Verdelingsstrategieën Om uw model over meerdere TPU's (evenals meerdere GPU's of meerdere machines) te distribueren, biedt TensorFlow de API. U kunt uw distributiestrategie vervangen en het model wordt uitgevoerd op elk gegeven (TPU) apparaat. De gids . tf.distribute.Strategy Distribueerde training met TensorFlow Het gebruik van de optie implementeert synchrone gedistribueerde training. TPU's bieden hun eigen implementatie van efficiënte all-reduce en andere collectieve operaties over meerdere TPU-kernen, die worden gebruikt in . tf.distribute.TPUStrategy TPUStrategy Om dit te laten zien, creëer je een Het object: tf.distribute.TPUStrategy strategy = tf.distribute.TPUStrategy(resolver) INFO:tensorflow:Found TPU system: INFO:tensorflow:Found TPU system: INFO:tensorflow:*** Num TPU Cores: 8 INFO:tensorflow:*** Num TPU Cores: 8 INFO:tensorflow:*** Num TPU Workers: 1 INFO:tensorflow:*** Num TPU Workers: 1 INFO:tensorflow:*** Num TPU Cores Per Worker: 8 INFO:tensorflow:*** Num TPU Cores Per Worker: 8 INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0) Om een berekening te repliceren zodat deze in alle TPU-kernen kan worden uitgevoerd, kunt u deze doorgeven aan de API. Hieronder is een voorbeeld dat alle kernen toont die dezelfde inputs ontvangen en matrixvermenigvuldiging op elke kern onafhankelijk uit te voeren.De outputs zijn de waarden van alle replicas. Strategy.run (a, b) @tf.function def matmul_fn(x, y): z = tf.matmul(x, y) return z z = strategy.run(matmul_fn, args=(a, b)) print(z) PerReplica:{ 0: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 1: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 2: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 3: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 4: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 5: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 6: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32), 7: tf.Tensor( [[22. 28.] [49. 64.]], shape=(2, 2), dtype=float32) } Classificatie op TPU's Nadat u de basisconcepten hebt behandeld, overweeg dan een concreet voorbeeld.Deze sectie laat zien hoe u de distributiestrategie kunt gebruiken. een Keras-model op een Cloud TPU trainen. tf.distribute.TPUStrategy Definieer een Keras-model Begin met een definitie van a Keras-model voor beeldklassificatie op de MNIST-dataset. Het is niet anders dan wat je zou gebruiken als je op CPU's of GPU's zou trainen. , zodat de variabelen op elk TPU-apparaat kunnen worden gemaakt. Andere delen van de code hoeven niet binnen de De scope. Sequential Strategy.scope Strategy def create_model(): return tf.keras.Sequential( [tf.keras.layers.Conv2D(256, 3, activation='relu', input_shape=(28, 28, 1)), tf.keras.layers.Conv2D(256, 3, activation='relu'), tf.keras.layers.Flatten(), tf.keras.layers.Dense(256, activation='relu'), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10)]) Laden van de dataset Efficiënt gebruik van de API's zijn van cruciaal belang bij het gebruik van een Cloud TPU. U kunt meer weten over de prestaties van datasets in de . tf.data.Dataset Input pipeline prestatie gids Als u gebruik maakt van , moet u alle gegevensbestanden opslaan die door de TensorFlow worden gelezen in Als u gebruik maakt van , kunt u gegevens opslaan waar u maar wilt. Voor meer informatie over TPU Nodes en TPU VMs, raadpleegt u de De documentatie. TPU knopen Dataset Google Cloud Storage (GCS) oplossingen TPU VMs TPU systeemarchitectuur Voor de meeste gebruiksgevallen wordt aanbevolen om uw gegevens om te zetten in de Format en gebruik a om het te lezen. bekijk de Het is geen moeilijke vereiste en u kunt andere datasetlezers gebruiken, zoals of . TFRecord tf.data.TFRecordDataset TFRecord en tf.Example tutorial tf.data.FixedLengthRecordDataset tf.data.TextLineDataset U kunt hele kleine datasets in het geheugen laden met . tf.data.Dataset.cache Ongeacht het gebruikte gegevensformaat wordt het sterk aanbevolen om grote bestanden in de volgorde van 100 MB te gebruiken.Dit is vooral belangrijk in deze netwerkomgeving, omdat de overhead van het openen van een bestand aanzienlijk hoger is. Zoals weergegeven in de onderstaande code, moet u de Tensorflow Datasets gebruiken module om een kopie van de MNIST training en testgegevens te krijgen. is gespecificeerd om een kopie te gebruiken die beschikbaar is in een openbare GCS bucket. Als u dit niet opgeeft, zal de TPU geen toegang hebben tot de gedownloade gegevens. tfds.load try_gcs def get_dataset(batch_size, is_training=True): split = 'train' if is_training else 'test' dataset, info = tfds.load(name='mnist', split=split, with_info=True, as_supervised=True, try_gcs=True) # Normalize the input data. def scale(image, label): image = tf.cast(image, tf.float32) image /= 255.0 return image, label dataset = dataset.map(scale) # Only shuffle and repeat the dataset in training. The advantage of having an # infinite dataset for training is to avoid the potential last partial batch # in each epoch, so that you don't need to think about scaling the gradients # based on the actual batch size. if is_training: dataset = dataset.shuffle(10000) dataset = dataset.repeat() dataset = dataset.batch(batch_size) return dataset Train het model met behulp van Keras high-level API's Je kunt je model trainen met Keras en Er is niets TPU-specifiek in deze stap - je schrijft de code alsof je meerdere GPU's en een In plaats van de Je kunt meer leren in de De tutorials. Model.fit Model.compile MirroredStrategy TPUStrategy Distribueerde training met Keras with strategy.scope(): model = create_model() model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['sparse_categorical_accuracy']) batch_size = 200 steps_per_epoch = 60000 // batch_size validation_steps = 10000 // batch_size train_dataset = get_dataset(batch_size, is_training=True) test_dataset = get_dataset(batch_size, is_training=False) model.fit(train_dataset, epochs=5, steps_per_epoch=steps_per_epoch, validation_data=test_dataset, validation_steps=validation_steps) Epoch 1/5 300/300 [==============================] - 17s 32ms/step - loss: 0.1235 - sparse_categorical_accuracy: 0.9620 - val_loss: 0.0462 - val_sparse_categorical_accuracy: 0.9856 Epoch 2/5 300/300 [==============================] - 7s 24ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9894 - val_loss: 0.0401 - val_sparse_categorical_accuracy: 0.9878 Epoch 3/5 300/300 [==============================] - 7s 24ms/step - loss: 0.0186 - sparse_categorical_accuracy: 0.9938 - val_loss: 0.0352 - val_sparse_categorical_accuracy: 0.9900 Epoch 4/5 300/300 [==============================] - 7s 25ms/step - loss: 0.0127 - sparse_categorical_accuracy: 0.9957 - val_loss: 0.0482 - val_sparse_categorical_accuracy: 0.9879 Epoch 5/5 300/300 [==============================] - 7s 24ms/step - loss: 0.0111 - sparse_categorical_accuracy: 0.9962 - val_loss: 0.0448 - val_sparse_categorical_accuracy: 0.9894 Om de overhead van Python te verminderen en de prestaties van uw TPU te maximaliseren, passeer in de Argument voor Keras In dit voorbeeld verhoogt het de doorvoer met ongeveer 50%: steps_per_execution Model.compile with strategy.scope(): model = create_model() model.compile(optimizer='adam', # Anything between 2 and `steps_per_epoch` could help here. steps_per_execution = 50, loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['sparse_categorical_accuracy']) model.fit(train_dataset, epochs=5, steps_per_epoch=steps_per_epoch, validation_data=test_dataset, validation_steps=validation_steps) Epoch 1/5 300/300 [==============================] - 14s 45ms/step - loss: 0.1306 - sparse_categorical_accuracy: 0.9591 - val_loss: 0.0420 - val_sparse_categorical_accuracy: 0.9863 Epoch 2/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9900 - val_loss: 0.0502 - val_sparse_categorical_accuracy: 0.9846 Epoch 3/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0193 - sparse_categorical_accuracy: 0.9936 - val_loss: 0.0406 - val_sparse_categorical_accuracy: 0.9879 Epoch 4/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0135 - sparse_categorical_accuracy: 0.9955 - val_loss: 0.0416 - val_sparse_categorical_accuracy: 0.9882 Epoch 5/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0110 - sparse_categorical_accuracy: 0.9962 - val_loss: 0.0463 - val_sparse_categorical_accuracy: 0.9882 Train het model met behulp van een custom training loop U kunt ook uw model maken en trainen met behulp van en API's direct. U kunt de Vuur om te verspreiden een datasetfunctie. Merk op dat in het onderstaande voorbeeld de batchgrootte in de is de batchgrootte per replica in plaats van de totale batchgrootte. De tutorials. tf.function tf.distribute Strategy.experimental_distribute_datasets_from_function tf.data.Dataset Dataset Custom training met tf.distribute.Strategy Eerst het model, de datasets en van s: tf.function # Create the model, optimizer and metrics inside the `tf.distribute.Strategy` # scope, so that the variables can be mirrored on each device. with strategy.scope(): model = create_model() optimizer = tf.keras.optimizers.Adam() training_loss = tf.keras.metrics.Mean('training_loss', dtype=tf.float32) training_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( 'training_accuracy', dtype=tf.float32) # Calculate per replica batch size, and distribute the `tf.data.Dataset`s # on each TPU worker. per_replica_batch_size = batch_size // strategy.num_replicas_in_sync train_dataset = strategy.experimental_distribute_datasets_from_function( lambda _: get_dataset(per_replica_batch_size, is_training=True)) @tf.function def train_step(iterator): """The step function for one training step.""" def step_fn(inputs): """The computation to run on each TPU device.""" images, labels = inputs with tf.GradientTape() as tape: logits = model(images, training=True) loss = tf.keras.losses.sparse_categorical_crossentropy( labels, logits, from_logits=True) loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(list(zip(grads, model.trainable_variables))) training_loss.update_state(loss * strategy.num_replicas_in_sync) training_accuracy.update_state(labels, logits) strategy.run(step_fn, args=(next(iterator),)) WARNING:tensorflow:From /tmpfs/tmp/ipykernel_9094/1509474074.py:14: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version. Instructions for updating: rename to distribute_datasets_from_function WARNING:tensorflow:From /tmpfs/tmp/ipykernel_9094/1509474074.py:14: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version. Instructions for updating: rename to distribute_datasets_from_function Voer vervolgens de training loop uit: steps_per_eval = 10000 // batch_size train_iterator = iter(train_dataset) for epoch in range(5): print('Epoch: {}/5'.format(epoch)) for step in range(steps_per_epoch): train_step(train_iterator) print('Current step: {}, training loss: {}, accuracy: {}%'.format( optimizer.iterations.numpy(), round(float(training_loss.result()), 4), round(float(training_accuracy.result()) * 100, 2))) training_loss.reset_states() training_accuracy.reset_states() Epoch: 0/5 Current step: 300, training loss: 0.1465, accuracy: 95.4% Epoch: 1/5 Current step: 600, training loss: 0.035, accuracy: 98.94% Epoch: 2/5 Current step: 900, training loss: 0.0197, accuracy: 99.39% Epoch: 3/5 Current step: 1200, training loss: 0.0126, accuracy: 99.59% Epoch: 4/5 Current step: 1500, training loss: 0.0109, accuracy: 99.64% Verbeter de prestaties met meerdere stappen binnen tf.function U kunt de prestaties verbeteren door meerdere stappen in een Dit wordt bereikt door het verpakken van de Bellen met een Binnenin , en AutoGraph zal het omzetten in een op de TPU werknemer. U kunt meer leren over S in de De gids . tf.function Strategy.run tf.range tf.function tf.while_loop tf.function Betere prestaties met tf.function Ondanks de verbeterde prestaties, zijn er compromissen met deze methode in vergelijking met het uitvoeren van een enkele stap binnen een Meerdere stappen in een is minder flexibel – je kunt dingen niet graag uitvoeren of willekeurige Python-code binnen de stappen. tf.function tf.function @tf.function def train_multiple_steps(iterator, steps): """The step function for one training step.""" def step_fn(inputs): """The computation to run on each TPU device.""" images, labels = inputs with tf.GradientTape() as tape: logits = model(images, training=True) loss = tf.keras.losses.sparse_categorical_crossentropy( labels, logits, from_logits=True) loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(list(zip(grads, model.trainable_variables))) training_loss.update_state(loss * strategy.num_replicas_in_sync) training_accuracy.update_state(labels, logits) for _ in tf.range(steps): strategy.run(step_fn, args=(next(iterator),)) # Convert `steps_per_epoch` to `tf.Tensor` so the `tf.function` won't get # retraced if the value changes. train_multiple_steps(train_iterator, tf.convert_to_tensor(steps_per_epoch)) print('Current step: {}, training loss: {}, accuracy: {}%'.format( optimizer.iterations.numpy(), round(float(training_loss.result()), 4), round(float(training_accuracy.result()) * 100, 2))) Current step: 1800, training loss: 0.009, accuracy: 99.72% Volgende stappen Meer informatie over Cloud TPU's en hoe u ze kunt gebruiken: Google Cloud TPU: De Google Cloud TPU homepage. : Google Cloud TPU documentation, which includes: Google Cloud TPU documentation : An overview of working with Cloud TPUs. Introduction to Cloud TPU : Quickstart introductions to working with Cloud TPU VMs using TensorFlow and other main machine learning frameworks. Cloud TPU quickstarts Google Cloud TPU Colab-notebooks: voorbeelden van end-to-end training. Google Cloud TPU-prestatiegids: verbeteren van de prestaties van Cloud TPU door de configuratieparameters van Cloud TPU voor uw applicatie aan te passen Gedistribueerde training met TensorFlow: Hoe distributiestrategieën te gebruiken, waaronder tf.distribute.TPUStrategy, met voorbeelden van beste praktijken. TPU-embeddings: TensorFlow bevat gespecialiseerde ondersteuning voor training embeddings op TPU's via tf.tpu.experimental.embedding. Bovendien heeft TensorFlow Recommenders tfrs.layers.embedding.TPUEmbedding. Embeddings zorgen voor efficiënte en dichte representaties, waarbij complexiteiten en relaties tussen functies worden vastgelegd. TPU-specifieke embeddingsupport van TensorFlow stelt u in staat om embeddings te trainen die groter zijn dan het geheugen van een enkel TPU-apparaat, en om schaarse en rogged-inputs op TPU's te gebruiken. TPU Research Cloud (TRC): TRC stelt onderzoekers in staat om toegang te aanvragen tot een cluster van meer dan 1.000 Cloud TPU-apparaten. Oorspronkelijk gepubliceerd op de website van TensorFlow, verschijnt dit artikel hier onder een nieuwe kop en is gelicentieerd onder CC BY 4.0. Oorspronkelijk gepubliceerd op de website van TensorFlow, verschijnt dit artikel hier onder een nieuwe kop en is gelicentieerd onder CC BY 4.0. De TensorFlow De TensorFlow