Yardım Kaggle üzerinde TensorFlow ile Büyük Bariyer Resifi korumak Meydan Üyelik

TPU'ları kullanın

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

Süre> Değiştir zamanı tür> Donanım hızlandırıcı> TPU: Bu CoLab dizüstü çalıştırmadan önce emin donanım hızlandırıcı dizüstü ayarları kontrol ederek bir TPU olduğunu olun.

Kurmak

import tensorflow as tf

import os
import tensorflow_datasets as tfds
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/requests/__init__.py:104: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (2.3.0)/charset_normalizer (2.0.8) doesn't match a supported version!
  RequestsDependencyWarning)

TPU başlatma

TPU'lar, genellikle, kullanıcının Python programını çalıştıran yerel süreçten farklı olan Cloud TPU çalışanlarıdır. Bu nedenle, uzak kümeye bağlanmak ve TPU'ları başlatmak için bazı başlatma çalışmaları yapmanız gerekir. Not tpu için argüman tf.distribute.cluster_resolver.TPUClusterResolver sadece CoLab için özel bir adres. Kodunuzu Google Compute Engine'de (GCE) çalıştırıyorsanız, bunun yerine Cloud TPU'nuzun adını iletmelisiniz.

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:Clearing out eager caches
INFO:tensorflow:Clearing out eager caches
INFO:tensorflow:Initializing the TPU system: grpc://10.240.1.2:8470
INFO:tensorflow:Initializing the TPU system: grpc://10.240.1.2: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')]

Manuel cihaz yerleştirme

TPU başlatıldıktan sonra, hesaplamayı tek bir TPU aygıtına yerleştirmek için manuel aygıt yerleştirmeyi kullanabilirsiniz:

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)

Dağıtım stratejileri

Genellikle modelinizi veri paralel bir şekilde birden çok TPU üzerinde çalıştırırsınız. Modelinizi birden çok TPU'ya (veya diğer hızlandırıcılara) dağıtmak için TensorFlow çeşitli dağıtım stratejileri sunar. Dağıtım stratejinizi değiştirebilirsiniz ve model herhangi bir (TPU) cihazda çalışacaktır. Kontrol dağıtım strateji rehberi Daha fazla bilgi için.

Bunu göstermek için, bir oluşturmak tf.distribute.TPUStrategy nesnesi:

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)

Hepsi TPU çekirdeklerinde çalışabilmesi için bir hesaplama çoğaltmak için, içine geçebilir strategy.run API. Aşağıdaki tablo tüm çekirdekler aynı girdiler almaya dair bir örnek (a, b) ve her biri bağımsız bir çekirdek üzerine matris çarpımını gerçekleştirilmesi. Çıktılar, tüm kopyalardan alınan değerler olacaktır.

@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)
}

TPU'larda sınıflandırma

Temel kavramları ele aldıktan sonra, daha somut bir örnek düşünün. Bu bölüm dağılımınızın Stratejisi- nasıl kullanılacağını göstermektedir tf.distribute.TPUStrategy Bulut TPU üzerinde Keras modeli eğitmek olmak oluşturuyor.

Bir Keras modeli tanımlayın

Bir tanımı ile başlayın Sequential keras kullanarak MNIST veri kümesi üzerinde görüntü sınıflandırma için Keras modeli. CPU'lar veya GPU'lar üzerinde eğitim alıyor olsaydınız, kullanacağınızdan farklı değil. Keras modeli oluşturma ihtiyacı içinde olmak olduğunu Not strategy.scope değişkenleri her TPU cihazda oluşturulabilir, böylece. Kodun diğer bölümlerinin strateji kapsamı içinde olması gerekli değildir.

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)])

Veri kümesini yükleyin

Etkin kullanımı tf.data.Dataset Eğer yeterince hızlı onları verileri besleyebilir sürece Bulut TPU kullanmak imkansız gibi bir bulut TPU kullanırken API kritiktir. İçeri veri kümesi performansı hakkında daha fazla bilgi edinebilirsiniz Girdi boru hattı performans rehber .

Tüm ama (kullanarak en basit deneyler için tf.data.Dataset.from_tensor_slices veya diğer in-grafiğin verilerini), tüm veri dosyaları Google Cloud Depolama Veri Dizisi (GCS) kovalar tarafından okunan saklamak gerekir.

En kullanım durumları için, verilerinizi dönüştürmek için önerilir TFRecord formatı ve bir kullanma tf.data.TFRecordDataset okumak için. Kontrol TFRecord ve tf.Example öğretici bu nasıl yapılacağına ilişkin ayrıntılar için. Zor bir gereklilik değildir ve gibi diğer veri kümesi okuyucuları kullanabilirsiniz tf.data.FixedLengthRecordDataset veya tf.data.TextLineDataset .

Sen kullanarak belleğe tüm küçük veri setlerini yükleyebilirsiniz tf.data.Dataset.cache .

Kullanılan veri formatı ne olursa olsun, 100MB mertebesinde büyük dosyaları kullanmanız şiddetle tavsiye edilir. Bu, bir dosya açmanın ek yükü önemli ölçüde daha yüksek olduğundan, bu ağ ortamında özellikle önemlidir.

Aşağıdaki kodda gösterildiği gibi, kullanmak gerekir tensorflow_datasets MNIST eğitim ve test verilerinin bir kopyasını almak modülü. O Not try_gcs bir kamu GCS mevcuttur Kopya kullanmak belirtildi. Bunu belirtmezseniz TPU indirilen verilere erişemez.

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

Modeli Keras üst düzey API'lerini kullanarak eğitin

Sen Keras ile modelinizi eğitebilirsiniz fit ve compile API'ler. Eğer mutliple GPU'ları ve bir kullanıyormuş gibi bu adım-sen kod yazmak bir şey TPU özgü yoktur MirroredStrategy yerine TPUStrategy . Sen daha fazla bilgi edinebilirsiniz Keras ile Dağıtılmış eğitim öğretici.

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 [==============================] - 18s 32ms/step - loss: 0.1291 - sparse_categorical_accuracy: 0.9590 - val_loss: 0.0410 - val_sparse_categorical_accuracy: 0.9871
Epoch 2/5
300/300 [==============================] - 6s 22ms/step - loss: 0.0335 - sparse_categorical_accuracy: 0.9892 - val_loss: 0.0492 - val_sparse_categorical_accuracy: 0.9847
Epoch 3/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0205 - sparse_categorical_accuracy: 0.9941 - val_loss: 0.0457 - val_sparse_categorical_accuracy: 0.9868
Epoch 4/5
300/300 [==============================] - 7s 22ms/step - loss: 0.0115 - sparse_categorical_accuracy: 0.9960 - val_loss: 0.0428 - val_sparse_categorical_accuracy: 0.9891
Epoch 5/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0110 - sparse_categorical_accuracy: 0.9965 - val_loss: 0.0592 - val_sparse_categorical_accuracy: 0.9853
<keras.callbacks.History at 0x7f25fc108a58>

Python yükünü azaltmak ve TPU performansını maksimize etmek için, argument- geçmek steps_per_execution Yapılır Model.compile . Bu örnekte, verimi yaklaşık %50 oranında artırır:

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 [==============================] - 13s 42ms/step - loss: 0.1343 - sparse_categorical_accuracy: 0.9594 - val_loss: 0.0487 - val_sparse_categorical_accuracy: 0.9837
Epoch 2/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0348 - sparse_categorical_accuracy: 0.9891 - val_loss: 0.0401 - val_sparse_categorical_accuracy: 0.9876
Epoch 3/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0187 - sparse_categorical_accuracy: 0.9940 - val_loss: 0.0517 - val_sparse_categorical_accuracy: 0.9844
Epoch 4/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0123 - sparse_categorical_accuracy: 0.9963 - val_loss: 0.0506 - val_sparse_categorical_accuracy: 0.9860
Epoch 5/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0080 - sparse_categorical_accuracy: 0.9974 - val_loss: 0.0456 - val_sparse_categorical_accuracy: 0.9878
<keras.callbacks.History at 0x7f23ac7782b0>

Özel bir eğitim döngüsü kullanarak modeli eğitin

Ayrıca oluşturup kullanarak modelinizi eğitebilirsiniz tf.function ve tf.distribute doğrudan API'leri. Sen kullanabilirsiniz strategy.experimental_distribute_datasets_from_function bir veri kümesi fonksiyonu verilen veri kümesi dağıtmak için API. Aşağıdaki örnekte, veri kümesine iletilen toplu iş boyutunun, genel toplu iş boyutu yerine çoğaltma başına toplu iş boyutu olduğuna dikkat edin. Daha fazla bilgi için check out tf.distribute.Strategy ile özel eğitim öğretici.

İlk önce modeli, veri kümelerini ve tf.işlevlerini oluşturun:

# Create the model, optimizer and metrics inside the 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 datasets 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 <ipython-input-1-5625c2a14441>:15: 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 <ipython-input-1-5625c2a14441>:15: 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

Ardından, eğitim döngüsünü çalıştırın:

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.1436, accuracy: 95.42%
Epoch: 1/5
Current step: 600, training loss: 0.0342, accuracy: 98.94%
Epoch: 2/5
Current step: 900, training loss: 0.0205, accuracy: 99.36%
Epoch: 3/5
Current step: 1200, training loss: 0.0123, accuracy: 99.59%
Epoch: 4/5
Current step: 1500, training loss: 0.0089, accuracy: 99.68%

İçeride çok adımlı Performansı artırma tf.function

Bir dahilinde birden çok adım çalıştırarak performansı artırabilir tf.function . Bu etiketleri içine alarak strategy.run bir ile çağrı tf.rangetf.function ve imzamı bir dönüştürecektir tf.while_loop TPU işçisi üzerinde.

Geliştirilmiş performans rağmen, içinde tek bir adım çalışan göre bu yöntem ile karşılaştırılması vardır tf.function . Bir birden çok adım Koşu tf.function az esnek-sizsiniz heyecanla şeyler çalıştırmak veya adımlar içindeki keyfi Python kodu olamaz.

@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.0093, accuracy: 99.68%

Sonraki adımlar