Dağıtılmış Eğitim

Dağıtılmış eğitim, bilgi işlem kaynakları gereksinimlerinin (örneğin CPU, RAM) birden fazla bilgisayar arasında dağıtıldığı bir model eğitim türüdür. Dağıtılmış eğitim, daha hızlı ve daha büyük veri kümeleri (birkaç milyar örneğe kadar) üzerinde eğitim yapılmasına olanak tanır.

Dağıtılmış eğitim, birden fazla modelin paralel olarak eğitildiği otomatik hiper parametre optimizasyonu için de kullanışlıdır.

Bu belgede şunları nasıl yapacağınızı öğreneceksiniz:

• Dağıtılmış eğitimi kullanarak bir TF-DF modelini eğitin.
• Dağıtılmış eğitimi kullanarak bir TF-DF modelinin hiper parametrelerini ayarlayın.

Sınırlamalar

Şu an itibariyle dağıtılmış eğitim aşağıdakiler için desteklenmektedir:

• Gradient Boosted Trees modellerini tfdf.keras.DistributedGradientBoostedTreesModel ile eğitme. Dağıtılmış Gradyan Destekli Ağaç modelleri, dağıtılmamış benzerleriyle eşdeğerdir.
• Herhangi bir TF-DF model türü için hiper parametre araması.

Dağıtılmış eğitim nasıl etkinleştirilir

Bu bölümde dağıtılmış eğitimin etkinleştirilmesine yönelik adımlar listelenmektedir. Örneklerin tamamı için sonraki bölüme bakın.

ParameterServerStrateji kapsamı

Model ve veri kümesi bir ParameterServerStrategy kapsamında tanımlanır.

strategy = tf.distribute.experimental.ParameterServerStrategy(...)
with strategy.scope():
  model = tfdf.keras.DistributedGradientBoostedTreesModel()
  distributed_train_dataset = strategy.distribute_datasets_from_function(dataset_fn)
model.fit(distributed_train_dataset)

Veri kümesi biçimi

Dağıtılmamış eğitimde olduğu gibi veri kümeleri şu şekilde sağlanabilir:

1. Sonlu bir tensor akışı dağıtılmış veri kümesi veya
2. uyumlu veri kümesi formatlarından birini kullanan veri kümesi dosyalarının yolu.

Parçalanmış dosyaları kullanmak, sonlu tensor akışı dağıtılmış veri kümesi yaklaşımını (1 satıra karşı ~20 satır kod) kullanmaktan önemli ölçüde daha basittir. Ancak yalnızca tensorflow veri kümesi yaklaşımı TensorFlow ön işlemeyi destekler. İşlem hattınız herhangi bir ön işleme içermiyorsa parçalanmış veri kümesi seçeneği önerilir.

Her iki durumda da, veri kümesi okumasını verimli bir şekilde dağıtmak için veri kümesinin birden fazla dosyaya bölünmesi gerekir.

Kurulum çalışanları

Başlıca süreç, TensorFlow modelini tanımlayan python kodunu çalıştıran programdır. Bu işlem herhangi bir ağır hesaplama çalıştırmıyor. Etkili eğitim hesaplaması işçiler tarafından yapılır. İşçiler, TensorFlow Parametre Sunucusunu çalıştıran süreçlerdir.

Şef, çalışanların IP adresiyle yapılandırılmalıdır. Bu, TF_CONFIG ortam değişkeni kullanılarak veya bir ClusterResolver oluşturularak yapılabilir. Daha fazla ayrıntı için ParameterServerStrategy ile Parametre sunucusu eğitimine bakın.

TensorFlow'un ParameterServerStrategy'si iki tür çalışanı tanımlar: "işçiler" ve "parametre sunucusu". TensorFlow, her çalışan türünden en az birinin başlatılmasını gerektirir. Ancak TF-DF yalnızca "işçileri" kullanıyor. Bu nedenle, bir "parametre sunucusunun" başlatılması gerekir ancak TF-DF tarafından kullanılmayacaktır. Örneğin, bir TF-DF eğitiminin konfigürasyonu aşağıdaki gibi görünebilir:

• 1 Şef
• 50 İşçi
• 1 Parametre sunucusu

Çalışanların TensorFlow Decision Forests'ın özel eğitim operasyonlarına erişmeleri gerekiyor. Erişimi etkinleştirmek için iki seçenek vardır:

1. Önceden yapılandırılmış TF-DF C++ Parametre Sunucusunu kullanın //third_party/tensorflow_decision_forests/tensorflow/distribute:tensorflow_std_server .
2. tf.distribute.Server() öğesini çağırarak bir parametre sunucusu oluşturun. Bu durumda TF-DF, import tensorflow_decision_forests aktarılmalıdır.

Örnekler

Bu bölümde dağıtılmış eğitim yapılandırmalarının tam örnekleri gösterilmektedir. Daha fazla örnek için TF-DF birim testlerini kontrol edin.

Örnek: Veri kümesi yolunda dağıtılmış eğitim

Uyumlu veri kümesi formatlarından birini kullanarak veri kümenizi parçalanmış dosyalar kümesine bölün. Dosyaları şu şekilde adlandırmanız önerilir: /path/to/dataset/train-<5 digit index>-of-<total files> , örneğin

/path/to/dataset/train-00000-of-00100
/path/to/dataset/train-00001-of-00005
/path/to/dataset/train-00002-of-00005
...

Maksimum verimlilik için dosya sayısı çalışan sayısının en az 10 katı olmalıdır. Örneğin 100 çalışanla eğitim veriyorsanız veri kümesinin en az 1000 dosyaya bölündüğünden emin olun.

Dosyalara daha sonra aşağıdaki gibi bir parçalama ifadesiyle başvurulabilir:

• /yol/giden/veri kümesi/eğitim@1000
• /yol/giden/veri kümesi/eğitim@*

Dağıtılmış eğitim şu şekilde yapılır. Bu örnekte veri kümesi, TensorFlow Örneklerinin bir TFRecord'u olarak depolanır ( tfrecord+tfe anahtarıyla tanımlanır).

import tensorflow_decision_forests as tfdf
import tensorflow as tf

strategy = tf.distribute.experimental.ParameterServerStrategy(...)

with strategy.scope():
  model = tfdf.keras.DistributedGradientBoostedTreesModel()

model.fit_on_dataset_path(
    train_path="/path/to/dataset/train@1000",
    label_key="label_key",
    dataset_format="tfrecord+tfe")

print("Trained model")
model.summary()

Örnek: Sonlu bir TensorFlow dağıtılmış veri kümesi üzerinde dağıtılmış eğitim

TF-DF, dağıtılmış, sınırlı, çalışan tarafından parçalanmış bir TensorFlow veri kümesi bekliyor:

• Dağıtılmış : Dağıtılmamış bir veri kümesi, strategy.distribute_datasets_from_function içine sarılır.
• sonlu : Veri kümesi her örneği tam olarak bir kez okumalıdır. Veri kümesi herhangi bir repeat talimatı içermemelidir .
• işçi-parçalanmış : Her çalışan, veri kümesinin ayrı bir bölümünü okumalıdır.

İşte bir örnek:

import tensorflow_decision_forests as tfdf
import tensorflow as tf


def dataset_fn(context, paths):
  """Create a worker-sharded finite dataset from paths.

  Like for non-distributed training, each example should be visited exactly
  once (and by only one worker) during the training. In addition, for optimal
  training speed, the reading of the examples should be distributed among the
  workers (instead of being read by a single worker, or read and discarded
  multiple times).

  In other words, don't add a "repeat" statement and make sure to shard the
  dataset at the file level and not at the example level.
  """

  # List the dataset files
  ds_path = tf.data.Dataset.from_tensor_slices(paths)

  # Make sure the dataset is used with distributed training.
  assert context is not None


  # Split the among the workers.
  #
  # Note: The "shard" is applied on the file path. The shard should not be
  # applied on the examples directly.
  # Note: You cannot use 'context.num_input_pipelines' with ParameterServerV2.
  current_worker = tfdf.keras.get_worker_idx_and_num_workers(context)
  ds_path = ds_path.shard(
      num_shards=current_worker.num_workers,
      index=current_worker.worker_idx)

  def read_csv_file(path):
    """Reads a single csv file."""

    numerical = tf.constant([0.0], dtype=tf.float32)
    categorical_string = tf.constant(["NA"], dtype=tf.string)
    csv_columns = [
        numerical,  # feature 1
        categorical_string,  # feature 2
        numerical,  # feature 3
        # ... define the features here.
    ]
    return tf.data.experimental.CsvDataset(path, csv_columns, header=True)

  ds_columns = ds_path.interleave(read_csv_file)

  # We assume a binary classification label with the following possible values.
  label_values = ["<=50K", ">50K"]

  # Convert the text labels into integers:
  # "<=50K" => 0
  # ">50K" => 1
  init_label_table = tf.lookup.KeyValueTensorInitializer(
      keys=tf.constant(label_values),
      values=tf.constant(range(label_values), dtype=tf.int64))
  label_table = tf.lookup.StaticVocabularyTable(
      init_label_table, num_oov_buckets=1)

  def extract_label(*columns):
    return columns[0:-1], label_table.lookup(columns[-1])

  ds_dataset = ds_columns.map(extract_label)

  # The batch size has no impact on the quality of the model. However, a larger
  # batch size generally is faster.
  ds_dataset = ds_dataset.batch(500)
  return ds_dataset


strategy = tf.distribute.experimental.ParameterServerStrategy(...)
with strategy.scope():
  model = tfdf.keras.DistributedGradientBoostedTreesModel()

  train_dataset = strategy.distribute_datasets_from_function(
      lambda context: dataset_fn(context, [...list of csv files...])
  )

model.fit(train_dataset)

print("Trained model")
model.summary()

Örnek: Bir veri kümesi yolunda dağıtılmış hiper parametre ayarı

Veri kümesi yolunda dağıtılmış hiper parametre ayarı, dağıtılmış eğitime benzer. Tek fark, bu seçeneğin dağıtılmayan modellerle uyumlu olmasıdır. Örneğin, (dağıtılmamış) Gradient Boosted Trees modelinin hiper parametre ayarını dağıtabilirsiniz.

with strategy.scope():
  tuner = tfdf.tuner.RandomSearch(num_trials=30, use_predefined_hps=True)
  model = tfdf.keras.GradientBoostedTreesModel(tuner=tuner)

training_history = model.fit_on_dataset_path(
  train_path=train_path,
  label_key=label,
  dataset_format="csv",
  valid_path=test_path)

logging.info("Trained model:")
model.summary()

Örnek: Birim testi

Dağıtılmış eğitimin birim testini yapmak için sahte çalışan süreçleri oluşturabilirsiniz. Daha fazla bilgi için TF-DF birim testlerinde _create_in_process_tf_ps_cluster yöntemine bakın.