code: def training_function(config, args):
      # For testing only
      if os.environ.get("TESTING_MOCKED_DATALOADERS", None) == "1":
          config["num_epochs"] = 2
      # Initialize Accelerator
  
      # New Code #
      # We pass in "all" to `log_with` to grab all available trackers in the environment
      # Note: If using a custom `Tracker` class, should be passed in here such as:
      # >>> log_with = ["all", MyCustomTrackerClassInstance()]
      if args.with_tracking:
          accelerator = Accelerator(
              cpu=args.cpu,
              mixed_precision=args.mixed_precision,
              log_with="all",
              project_dir=args.project_dir,
          )
      else:
          accelerator = Accelerator(
              cpu=args.cpu, mixed_precision=args.mixed_precision
          )
      # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
      lr = config["lr"]
      num_epochs = int(config["num_epochs"])
      seed = int(config["seed"])
      batch_size = int(config["batch_size"])
      set_seed(seed)
  
      train_dataloader, eval_dataloader = get_dataloaders(
          accelerator, batch_size
      )
      metric = evaluate.load("glue", "mrpc")
  
      # If the batch size is too big we use gradient accumulation
      gradient_accumulation_steps = 1
      if (
          batch_size > MAX_GPU_BATCH_SIZE
          and accelerator.distributed_type != DistributedType.TPU
      ):
          gradient_accumulation_steps = batch_size // MAX_GPU_BATCH_SIZE
          batch_size = MAX_GPU_BATCH_SIZE
  
      # Instantiate the model (we build the model here so that the seed also control new weights initialization)
      model = AutoModelForSequenceClassification.from_pretrained(
          "bert-base-cased", return_dict=True
      )
  
      # We could avoid this line since the accelerator is set with `device_placement=True` (default value).
      # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
      # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
      model = model.to(accelerator.device)
  
      # Instantiate optimizer
      optimizer = AdamW(params=model.parameters(), lr=lr)
  
      # Instantiate scheduler
      lr_scheduler = get_linear_schedule_with_warmup(
          optimizer=optimizer,
          num_warmup_steps=100,
          num_training_steps=(len(train_dataloader) * num_epochs)
          // gradient_accumulation_steps,
      )
  
      # Prepare everything
      # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
      # prepare method.
      (
          model,
          optimizer,
          train_dataloader,
          eval_dataloader,
          lr_scheduler,
      ) = accelerator.prepare(
          model,
          optimizer,
          train_dataloader,
          eval_dataloader,
          lr_scheduler,
      )
  
      # New Code #
      # We need to initialize the trackers we use. Overall configurations can also be stored
      if args.with_tracking:
          run = os.path.split(__file__)[-1].split(".")[0]
          accelerator.init_trackers(run, config)
  
      # Now we train the model
      for epoch in range(num_epochs):
          model.train()
          # New Code #
          # For our tracking example, we will log the total loss of each epoch
          if args.with_tracking:
              total_loss = 0
          for step, batch in enumerate(train_dataloader):
              # We could avoid this line since we set the accelerator with `device_placement=True`.
              batch.to(accelerator.device)
              outputs = model(**batch)
              loss = outputs.loss
              # New Code #
              if args.with_tracking:
                  total_loss += loss.detach().float()
              loss = loss / gradient_accumulation_steps
              accelerator.backward(loss)
              if step % gradient_accumulation_steps == 0:
                  optimizer.step()
                  lr_scheduler.step()
                  optimizer.zero_grad()
  
          model.eval()
          for step, batch in enumerate(eval_dataloader):
              # We could avoid this line since we set the accelerator with `device_placement=True` (the default).
              batch.to(accelerator.device)
              with torch.no_grad():
                  outputs = model(**batch)
              predictions = outputs.logits.argmax(dim=-1)
              predictions, references = accelerator.gather_for_metrics(
                  (predictions, batch["labels"])
              )
              metric.add_batch(
                  predictions=predictions,
                  references=references,
              )
  
          eval_metric = metric.compute()
          # Use accelerator.print to print only on the main process.
          accelerator.print(f"epoch {epoch}:", eval_metric)
  
          # New Code #
          # To actually log, we call `Accelerator.log`
          # The values passed can be of `str`, `int`, `float` or `dict` of `str` to `float`/`int`
          if args.with_tracking:
              accelerator.log(
                  {
                      "accuracy": eval_metric["accuracy"],
                      "f1": eval_metric["f1"],
                      "train_loss": total_loss.item()
                      / len(train_dataloader),
                      "epoch": epoch,
                  },
                  step=epoch,
              )
  
      # New Code #
      # When a run is finished, you should call `accelerator.end_training()`
      # to close all of the open trackers
      if args.with_tracking:
          accelerator.end_training()
  
file_path: accelerate/examples/by_feature/tracking.py
imports: import argparse
  import os
  import evaluate
  import torch
  from datasets import load_dataset
  from torch.optim import AdamW
  from torch.utils.data import DataLoader
  from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
  from accelerate import Accelerator, DistributedType
label_desc: Use image node_id 2 for calling a global function with example usage: training_function(config, args) without return types