Deney izleyicileri

Kullanılabilir çok sayıda deney izleme API'si bulunmaktadır; ancak bunların hepsini çok işlemli bir ortamda çalıştırmak çoğu zaman karmaşık olabilir. Accelerate, betiğiniz sırasında Accelerator.log() aracılığıyla faydalı öğeleri günlüğe kaydetmek için kullanılabilen genel bir izleme API'si sağlar.

Entegre İzleyiciler

Şu anda Accelerate sekiz izleyiciyi kutudan çıktığı gibi destekler:

• TensorBoard
• WandB
• Trackio
• CometML
• Amaç
• MLFlow
• ClearML
• DVCLive

Bunlardan herhangi birini kullanmak için, seçilen tür(ler)i Accelerate içindeki log_with parametresine iletin:

from accelerate import Accelerator
from accelerate.utils import LoggerType

accelerator = Accelerator(log_with="all")  # For all available trackers in the environment
accelerator = Accelerator(log_with="wandb")
accelerator = Accelerator(log_with=["wandb", LoggerType.TENSORBOARD])

Deneyinizin başlangıcında projenizi yapılandırmak ve kaydedilecek deney hiperparametrelerini eklemek için Accelerator.init_trackers() kullanılmalıdır:

hps = {"num_iterations": 5, "learning_rate": 1e-2}
accelerator.init_trackers("my_project", config=hps)

Herhangi bir veriyi kaydetmeye hazır olduğunuzda Accelerator.log() kullanılmalıdır. Eğitim döngüsündeki belirli bir adımla veriyi ilişkilendirmek için bir step de geçirilebilir.

accelerator.log({"train_loss": 1.12, "valid_loss": 0.8}, step=1)

Eğitim tamamlandıktan sonra, tüm izleyicilerin varsa bitirme işlevlerini çalıştırabilmesi için Accelerator.end_training() çağrısını yapmayı unutmayın.

accelerator.end_training()

Aşağıda tam bir örnek bulunmaktadır:

from accelerate import Accelerator

accelerator = Accelerator(log_with="all")
config = {
    "num_iterations": 5,
    "learning_rate": 1e-2,
    "loss_function": str(my_loss_function),
}

accelerator.init_trackers("example_project", config=config)

my_model, my_optimizer, my_training_dataloader = accelerator.prepare(my_model, my_optimizer, my_training_dataloader)
device = accelerator.device
my_model.to(device)

for iteration in range(config["num_iterations"]):
    for step, batch in enumerate(my_training_dataloader):
        my_optimizer.zero_grad()
        inputs, targets = batch
        inputs = inputs.to(device)
        targets = targets.to(device)
        outputs = my_model(inputs)
        loss = my_loss_function(outputs, targets)
        accelerator.backward(loss)
        my_optimizer.step()
        accelerator.log({"training_loss": loss}, step=step)
accelerator.end_training()

Bir izleyicinin verileri kaydetmesi için bir dizine ihtiyacı varsa, örneğin TensorBoard, dizin yolunu project_dir parametresine iletin. project_dir parametresi, ProjectConfiguration veri sınıfında birleştirilecek diğer yapılandırmalar olduğunda kullanışlıdır. Örneğin, TensorBoard verilerini project_dir dizinine kaydedebilir ve her şeyi [~utils.ProjectConfiguration]'nin logging_dir parametresinde kaydedebilirsiniz:

accelerator = Accelerator(log_with="tensorboard", project_dir=".")

# use with ProjectConfiguration
config = ProjectConfiguration(project_dir=".", logging_dir="another/directory")
accelerator = Accelerator(log_with="tensorboard", project_config=config)

Özel Takıcılar Uygulama

Accelerator içinde kullanılacak yeni bir izleyici uygulamak için, GeneralTracker sınıfını uygulayarak yeni bir izleyici oluşturulabilir. Her izleyici üç fonksiyon uygulamalı ve üç özelliğe sahip olmalıdır:

• __init__:

  • run_name değerini depolamalı ve entegre kütüphanenin izleyici API'sini başlatmalıdır.
  • Bir izleyici verilerini yerel olarak saklıyorsa (TensorBoard gibi), logging_dir parametresi eklenebilir.

• store_init_configuration:

  • values sözlüğünü kabul etmeli ve bunları tek seferlik bir deneysel yapılandırma olarak saklamalıdır

• log:

  • values sözlüğünü ve step değerini almalı ve bunları çalıştırmaya (run) kaydetmelidir

• name (str):

  • Takipçi için benzersiz bir dize adı, örneğin wandb takipçisi için "wandb".
  • Bu, özellikle bu izleyiciyle etkileşim kurmak için kullanılacaktır

• requires_logging_directory (bool):

  • Bu belirli izleyici için logging_dir'a ihtiyaç olup olmadığı ve bir tane kullanıp kullanmadığı.

• tracker:

  • Bu, bir @property fonksiyonu olarak uygulanmalıdır
  • Kütüphanenin kullandığı dahili izleme mekanizmasını, örneğin wandb için run nesnesini döndürmelidir.

Her yöntem, örneğin kayıtçının yalnızca ana süreçte çalıştırılması gerekiyorsa, state.PartialState sınıfını da kullanmalıdır.

Aşağıda, yalnızca ilgili bilgileri içeren ve yalnızca ana işlemde günlük tutan, Weights and Biases ile entegrasyon içeren kısa bir örnek görülebilir:

from accelerate.tracking import GeneralTracker, on_main_process
from typing import Optional

import wandb


class MyCustomTracker(GeneralTracker):
    name = "wandb"
    requires_logging_directory = False

    @on_main_process
    def __init__(self, run_name: str):
        self.run_name = run_name
        run = wandb.init(self.run_name)

    @property
    def tracker(self):
        return self.run.run

    @on_main_process
    def store_init_configuration(self, values: dict):
        wandb.config(values)

    @on_main_process
    def log(self, values: dict, step: Optional[int] = None):
        wandb.log(values, step=step)

Accelerator nesnenizi oluşturmaya hazır olduğunuzda, izleyicinizin bir örneğini Accelerator.log_with parametresi olarak iletin; böylece API ile otomatik olarak kullanılır:

tracker = MyCustomTracker("some_run_name")
accelerator = Accelerator(log_with=tracker)

Bunlar, "all" dahil olmak üzere mevcut izleyicilerle de karıştırılabilir:

tracker = MyCustomTracker("some_run_name")
accelerator = Accelerator(log_with=[tracker, "all"])

Ad ile özel bir izleyici kaydetme

Bir örnek yerine, yerleşik izleyicilerde olduğu gibi name ile seçilebilmesi için özel bir izleyici sınıfı kaydedebilirsiniz. Kullanılacak izleyicilerin bir yapılandırma dosyasından veya komut satırından okunduğu durumlarda bu oldukça kullanışlıdır:

from accelerate import Accelerator
from accelerate.tracking import GeneralTracker, register_tracker_class


class MyCustomTracker(GeneralTracker):
    name = "my_tracker"
    requires_logging_directory = False
    # ... implement the rest of the `GeneralTracker` interface


register_tracker_class(MyCustomTracker)
accelerator = Accelerator(log_with="my_tracker")

Dahili izleyiciye erişim

Bir izleyiciyle doğrudan özel etkileşimler isteniyorsa, Accelerator.get_tracker() yöntemi kullanılarak hızlıca birine erişilebilir. Sadece bir izleyicinin .name özniteliğine karşılık gelen dizeyi iletin ve ana süreçte o izleyiciyi döndürecektir.

Bu örnek, bunu wandb ile yapmayı gösterir:

wandb_tracker = accelerator.get_tracker("wandb")

Buradan wandb'nin run nesnesiyle normal şekilde etkileşime geçebilirsiniz:

wandb_tracker.log_artifact(some_artifact_to_log)

Trackers built in Accelerate will automatically execute on the correct process, so if a tracker is only meant to be ran on the main process it will do so automatically.

Accelerate sarmalayıcısını tamamen kaldırmak istiyorsanız, aynı sonucu şununla elde edebilirsiniz:

wandb_tracker = accelerator.get_tracker("wandb", unwrap=True)
if accelerator.is_main_process:
    wandb_tracker.log_artifact(some_artifact_to_log)

Bir sarmalayıcının çalışamadığı durumlar

Bir kütüphanenin, Neptune.AI gibi genel bir sözlük içeren katı bir .log yapısını takip etmeyen bir API'si varsa, loglama if accelerator.is_main_process ifadesi altında manuel olarak yapılabilir:

  from accelerate import Accelerator
+ import neptune

  accelerator = Accelerator()
+ run = neptune.init_run(...)

  my_model, my_optimizer, my_training_dataloader = accelerate.prepare(my_model, my_optimizer, my_training_dataloader)
  device = accelerator.device
  my_model.to(device)

  for iteration in config["num_iterations"]:
      for batch in my_training_dataloader:
          my_optimizer.zero_grad()
          inputs, targets = batch
          inputs = inputs.to(device)
          targets = targets.to(device)
          outputs = my_model(inputs)
          loss = my_loss_function(outputs, targets)
          total_loss += loss
          accelerator.backward(loss)
          my_optimizer.step()
+         if accelerator.is_main_process:
+             run["logs/training/batch/loss"].log(loss)