Paranna TensorFlow-harjoittelun nopeutta 50% näillä TPU-huijauksilla

Sisällön yleiskatsaus asennettu TPU:n aloittaminen » Manuaalinen asennus Jakelustrategioita Luokittelu TPUs Määrittele Kera-malli Lataa tietokone Koe malli Kerasin korkean tason API: n avulla Harjoittele mallia käyttämällä räätälöityä harjoittelurataa Suorituskyvyn parantaminen useilla vaiheilla tf.functionissa Seuraavat askeleet Tämä opas osoittaa, miten suorittaa peruskoulutus ja TPU Pods, kokoelma TPU-laitteita, jotka on yhdistetty erityisillä nopeilla verkko-liitännöillä, ja harjoitteluvaihtoehtoja. Tensorin käsittelyyksiköt (Tensor Processing Units, TPU) tf.keras TPU:t ovat Googlen räätälöityjä sovelluskohtaisia integroituja piirejä (ASIC), joita käytetään koneoppimisen työkuormien nopeuttamiseen. Se on ja . Googlen kolumni TPU tutkimuksen pilvi Pilvi TPU asennettu Ennen kuin käynnistät tämän Colab-muistikirjan, varmista, että laitteistosi kiihdytin on TPU tarkistamalla muistikirjan asetukset: > > > > > > . Runtime Change runtime type Hardware accelerator TPU Importoi joitakin tarvittavia kirjastoja, mukaan lukien TensorFlow-tietokokonaisuudet: 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 aloittaminen TPS on tyypillinen Työntekijät, jotka eroavat paikallisesta prosessista, jossa käyttäjän Python-ohjelma on käynnissä. Näin ollen sinun on tehtävä joitakin aloitustyötä, jotta voit muodostaa yhteyden etäklusteriin ja aloittaa TPU:t. Huomaa, että Argumentti on Jos käytät koodia Google Compute Engineissa (GCE), sinun pitäisi sen sijaan siirtää pilvipalvelun nimi. Pilvi TPU tpu tf.distribute.cluster_resolver.TPUClusterResolver Huomautus: TPU:n aloituskoodin on oltava ohjelman alussa. TPU:n aloituskoodin on oltava ohjelman alussa. 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')] Manuaalinen asennus Kun TPU on alustettu, voit käyttää manuaalista laitteen sijoittamista laskennan sijoittamiseen yhteen TPU-laitteeseen: 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) Jakelustrategioita Jos haluat jakaa mallisi useisiin TPU-yksiköihin (sekä useisiin GPU-yksiköihin tai useisiin koneisiin), TensorFlow tarjoaa Voit korvata jakelustrategian ja malli toimii millä tahansa tietyllä (TPU) laitteella. ja oppaan. tf.distribute.Strategy Jakautettu koulutus TensorFlowilla Käyttämällä sitä vaihtoehto toteuttaa synkronisen hajautetun koulutuksen. TPU: t tarjoavat oman tehokkaan all-reduce- ja muiden kollektiivisten toimintojen toteuttamisen useissa TPU-ydinissä, joita käytetään . tf.distribute.TPUStrategy TPUStrategy Tämän osoittamiseksi luodaan a kohteen mukaan: 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) Jos haluat toistaa laskentaa niin, että se voidaan suorittaa kaikissa TPU-ydinissä, voit siirtää sen API. Alla on esimerkki, joka osoittaa, että kaikki ytimet saavat samat syötteet ja suorittaa matriisin kertoimet kullakin ytimellä itsenäisesti. Tulokset ovat kaikkien replikoiden arvoja. 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) } Luokittelu TPUs Kun olet käsitellyt peruskäsitteet, harkitse konkreettisempaa esimerkkiä.Tässä osassa esitetään, miten jakelustrategiaa käytetään. Keras-mallin kouluttaminen pilvipalveluun. tf.distribute.TPUStrategy Määrittele Kera-malli Aloita määritelmällä a Keras-malli kuvan luokitteluun MNIST-tietokannassa. Se ei eroa siitä, mitä käytät, jos koulutat CPU: lla tai GPU:lla. Huomaa, että Keras-mallin luomisen on oltava sisällä , joten muuttujat voidaan luoda jokaiselle TPU-laitteelle. Muiden koodin osien ei tarvitse olla sisällä ja 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)]) Lataa tietokone tehokasta käyttöä varten API on ratkaisevan tärkeä, kun käytät pilvipohjaista TPU:ta. Voit oppia lisää datasettien suorituskyvystä . tf.data.Dataset Input Pipeline -suorituskykyopas Jos käytät , sinun on tallennettava kaikki TensorFlowin lukemat tiedostot Sisällä Jos käytät , voit tallentaa tietoja missä haluat. Lisätietoja TPU-solmuista ja TPU-VM:istä on osoitteessa ja dokumentaatioon. TPU solmut Dataset Googlen pilvipalvelut (GCS) Vms Vms TPU Järjestelmä Arkkitehtuuri Useimmissa käyttötapauksissa on suositeltavaa muuntaa tiedot Käytä ja muotoile a Lue lisää. Tutustu Tämä ei ole vaikea vaatimus, ja voit käyttää muita datasettien lukijoita, kuten tai . TFRecord tf.data.TFRecordDataset TFRecord ja tf.Example tutoriali tf.data.FixedLengthRecordDataset tf.data.TextLineDataset Voit ladata koko pieniä tietokokonaisuuksia muistiin käyttämällä . tf.data.Dataset.cache Riippumatta käytetystä tiedostomuodosta on erittäin suositeltavaa käyttää suuria tiedostoja, joiden koko on 100 MB. Tämä on erityisen tärkeää tässä verkostoituneessa ympäristössä, koska tiedoston avaamisen ylivoima on huomattavasti suurempi. Kuten alla olevassa koodissa näkyy, sinun tulee käyttää Tensorflow-tietokokonaisuutta. MNIST-koulutus- ja testaustietojen kopiointi. huomaa, että on määritetty käyttämään kopiota, joka on saatavilla julkisessa GCS-astiassa. Jos et määritä tätä, TPU ei voi käyttää ladattuja tietoja. 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 Koe malli Kerasin korkean tason API: n avulla Voit kouluttaa mallisi Kerasilla ja Tässä vaiheessa ei ole mitään TPU-spesifistä – kirjoitat koodin ikään kuin käytät useita GPU:ia ja Sen sijaan, että Voit oppia lisää alueella Tutorialin kanssa. Model.fit Model.compile MirroredStrategy TPUStrategy Jakautettu koulutus Kerasilla 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 Vähentääksesi Pythonin ylikuormitusta ja maksimoidaksesi TPU: n suorituskyvyn, siirry Argumentti koskee Tässä esimerkissä se lisää läpäisevyyttä noin 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 Harjoittele mallia käyttämällä räätälöityä harjoittelurataa Voit myös luoda ja kouluttaa mallia käyttämällä ja Vinkki: Voit käyttää sitä Ilotulitus jakaa Huomaa, että alla olevassa esimerkissä erän koko siirtyi on per-replica-erän koko globaalin erän koon sijaan. Lisätietoja on Tutorialin kanssa. tf.function tf.distribute Strategy.experimental_distribute_datasets_from_function tf.data.Dataset Dataset Mukautettu koulutus kanssa tf.distribute.Strategy Ensinnäkin luoda malli, datasetti ja S on: 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 Tämän jälkeen harjoittele harjoittelua: 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% Suorituskyvyn parantaminen useilla vaiheilla sisällä tf.function Voit parantaa suorituskykyä suorittamalla useita vaiheita Tämä saavutetaan leikkaamalla Soita A Sisällä , ja AutoGraph muuntaa sen a TPU-työntekijä. voit oppia lisää S:ssä on ja oppaan. tf.function Strategy.run tf.range tf.function tf.while_loop tf.function Parempi suorituskyky tf.function Huolimatta parantuneesta suorituskyvystä, tällä menetelmällä on kompromisseja verrattuna yhden askeleen suorittamiseen Käynnistä useita vaiheita a on vähemmän joustava – et voi ajaa asioita innokkaasti tai mielivaltaisesti Python-koodia vaiheissa. 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% Seuraavat askeleet Lue lisää pilvipalveluista ja niiden käytöstä: Google Cloud TPU: Google Cloud TPU:n kotisivu. : 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: End-to-end koulutus esimerkkejä. Google Cloud TPU:n suorituskykyopas: Paranna Cloud TPU:n suorituskykyä entisestään säätämällä sovelluksesi Cloud TPU:n konfigurointiparametreja Jakautettu koulutus TensorFlowilla: Miten käytetään jakelustrategioita, mukaan lukien tf.distribute.TPUSstrategy, esimerkkejä parhaista käytännöistä. TPU-sisääntely: TensorFlow sisältää erikoistuneen tuen TPU:n koulutussisääntelyille tf.tpu.experimental.embedding:n kautta. Lisäksi TensorFlow Recommendersissa on tfrs.layers.embedding.TPUEmbedding. Sisääntely tarjoaa tehokkaita ja tiheitä esityksiä, jotka tallentavat samankaltaisuuksia ja ominaisuuksien välisiä suhteita. TensorFlowin TPU-erityinen upottamistuki mahdollistaa yhden TPU-laitteen muistia suurempien sisääntelyjen kouluttamisen ja TPU-laitteiden harvinaisten ja ragged-sisääntelyjen käyttämisen. TPU Research Cloud (TRC): TRC antaa tutkijoille mahdollisuuden hakea pääsyä yli 1000 Cloud TPU -laitteen klusteriin. Alun perin julkaistu TensorFlow-verkkosivustolla, tämä artikkeli ilmestyy täällä uuden otsikon alla ja on lisensoitu CC BY 4.0. Alun perin julkaistu TensorFlow-verkkosivustolla, tämä artikkeli ilmestyy täällä uuden otsikon alla ja on lisensoitu CC BY 4.0. TensorFlowMuokkaa TensorFlowMuokkaa