Accelerate documentation

Huấn luyện trên TPU

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Huấn luyện trên TPU

Việc huấn luyện trên TPU có thể hơi khác so với huấn luyện trên nhiều GPU, ngay cả khi sử dụng Accelerate. Hướng dẫn này nhằm chỉ ra những điểm bạn cần lưu ý và lý do, cũng như các thực hành tốt nhất nói chung.

Huấn luyện trong Notebook

Điểm cần lưu ý chính khi huấn luyện trên TPU bắt nguồn từ notebook_launcher(). Như đã đề cập trong hướng dẫn notebook, bạn cần tái cấu trúc mã huấn luyện của mình thành một hàm có thể được truyền vào hàm notebook_launcher() và cẩn thận không khai báo bất kỳ tensor nào trên GPU.

Mặc dù trên TPU phần đó không quan trọng bằng, một phần quan trọng cần hiểu là khi bạn chạy mã từ notebook, bạn thực hiện điều đó thông qua một quá trình gọi là forking. Khi chạy từ dòng lệnh, bạn thực hiện spawning, trong đó một tiến trình python hiện không đang chạy và bạn spawn một tiến trình mới. Vì notebook Jupyter của bạn đã đang sử dụng một tiến trình python, bạn cần fork một tiến trình mới từ nó để chạy mã của mình.

Điều này trở nên quan trọng khi bạn khai báo mô hình của mình. Trên các tiến trình TPU được fork, bạn nên khởi tạo mô hình của mình một lần và truyền nó vào hàm huấn luyện. Điều này khác với việc huấn luyện trên GPU, nơi bạn tạo ra n mô hình có gradient được đồng bộ hóa và lan truyền ngược lại vào những thời điểm nhất định. Thay vào đó, một phiên bản mô hình duy nhất được chia sẻ giữa tất cả các nút và được truyền đi lại giữa chúng. Điều này đặc biệt quan trọng khi huấn luyện trên các TPU có tài nguyên thấp, chẳng hạn như những TPU được cung cấp trong các kernel Kaggle hoặc trên Google Colaboratory.

Dưới đây là một ví dụ về hàm huấn luyện được truyền vào notebook_launcher() nếu huấn luyện trên CPU hoặc GPU:

Mảnh mã này dựa trên mã trong notebook simple_nlp_example được tìm thấy tại đây với một số chỉnh sửa nhỏ để đơn giản hóa

def training_function():
    # Initialize accelerator
    accelerator = Accelerator()
    model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=2)
    train_dataloader, eval_dataloader = create_dataloaders(
        train_batch_size=hyperparameters["train_batch_size"], eval_batch_size=hyperparameters["eval_batch_size"]
    )

    # Instantiate optimizer
    optimizer = AdamW(params=model.parameters(), lr=hyperparameters["learning_rate"])

    # 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 = accelerator.prepare(
        model, optimizer, train_dataloader, eval_dataloader
    )

    num_epochs = hyperparameters["num_epochs"]
    # Now we train the model
    for epoch in range(num_epochs):
        model.train()
        for step, batch in enumerate(train_dataloader):
            outputs = model(**batch)
            loss = outputs.loss
            accelerator.backward(loss)

            optimizer.step()
            optimizer.zero_grad()
from accelerate import notebook_launcher

notebook_launcher(training_function)

notebook_launcher sẽ mặc định là 8 tiến trình nếu Accelerate đã được cấu hình cho TPU

Nếu bạn sử dụng ví dụ này và khai báo mô hình bên trong vòng lặp huấn luyện, thì trên hệ thống có tài nguyên thấp, bạn có thể gặp lỗi như:

ProcessExitedException: process 0 terminated with signal SIGSEGV

Lỗi này cực kỳ khó hiểu nhưng giải thích cơ bản là bạn đã hết RAM hệ thống. Bạn có thể tránh hoàn toàn điều này bằng cách cấu hình lại hàm huấn luyện để chấp nhận một đối số model duy nhất, và khai báo nó trong một cell bên ngoài:

# In another Jupyter cell
model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=2)
+ def training_function(model):
      # Initialize accelerator
      accelerator = Accelerator()
-     model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased", num_labels=2)
      train_dataloader, eval_dataloader = create_dataloaders(
          train_batch_size=hyperparameters["train_batch_size"], eval_batch_size=hyperparameters["eval_batch_size"]
      )
  ...

Và cuối cùng, gọi hàm huấn luyện với:

  from accelerate import notebook_launcher
- notebook_launcher(training_function)
+ notebook_launcher(training_function, (model,))

Cách xử lý tạm thời ở trên chỉ cần thiết khi khởi động một instance TPU từ Jupyter Notebook trên một máy chủ có tài nguyên thấp như Google Colaboratory hoặc Kaggle. Nếu sử dụng script hoặc khởi động trên một máy chủ mạnh hơn nhiều thì không cần khai báo model trước.

Độ chính xác hỗn hợp và Biến toàn cục

Như đã đề cập trong mục độ chính xác hỗn hợp của hướng dẫn di chuyển, Accelerate hỗ trợ fp16 và bf16, cả hai đều có thể được sử dụng trên TPU. Tuy nhiên, lý tưởng nhất là nên sử dụng bf16 vì nó cực kỳ hiệu quả.

Có hai “lớp” khi sử dụng bf16 và Accelerate trên TPU, ở mức cơ bản và ở mức thao tác.

Ở mức cơ bản, tính năng này được kích hoạt khi truyền mixed_precision="bf16" vào Accelerator, chẳng hạn như:

accelerator = Accelerator(mixed_precision="bf16")

Mặc định, điều này sẽ chuyển đổi torch.float và torch.double sang bfloat16 trên TPU. Cấu hình cụ thể được thiết lập là biến môi trường XLA_USE_BF16 được đặt thành 1.

Có một cấu hình khác bạn có thể thực hiện, đó là đặt biến môi trường XLA_DOWNCAST_BF16. Nếu được đặt thành 1, thì torch.float sẽ là bfloat16 và torch.double sẽ là float32.

Điều này được thực hiện trong đối tượng Accelerator khi truyền downcast_bf16=True:

accelerator = Accelerator(mixed_precision="bf16", downcast_bf16=True)

Việc sử dụng downcasting thay vì bf16 ở mọi nơi là hữu ích khi bạn cần tính toán các chỉ số, ghi log giá trị và nhiều tác vụ khác, nơi mà các tensor bf16 thô sẽ không thể sử dụng được.

Thời gian huấn luyện trên TPU

Khi bạn chạy script, bạn có thể nhận thấy rằng quá trình huấn luyện ban đầu có vẻ đặc biệt chậm. Điều này là do TPU trước tiên sẽ chạy qua một vài batch dữ liệu để xác định lượng bộ nhớ cần cấp phát, sau đó mới sử dụng lượng bộ nhớ đã cấu hình này một cách cực kỳ hiệu quả.

Nếu bạn nhận thấy rằng mã đánh giá của bạn để tính toán các chỉ số của mô hình mất nhiều thời gian hơn do việc sử dụng kích thước lô (batch size) lớn hơn, khuyến nghị là giữ nguyên kích thước lô giống như dữ liệu huấn luyện nếu quá trình này quá chậm. Nếu không, bộ nhớ sẽ được cấp phát lại cho kích thước lô mới này sau vài lần lặp đầu tiên.

Việc bộ nhớ được cấp phát không có nghĩa là nó sẽ được sử dụng hoặc kích thước lô (batch size) sẽ tăng lên khi quay lại bộ nạp dữ liệu huấn luyện của bạn.

Update on GitHub