Machine Learning: PyTorch 1.7 enthält neue APIs und unterstützt CUDA 11

Die aktuelle Version der ML-Plattform zielt auf Parität zwischen Python- und C++-Frontend und bietet ein Modul zum Implementieren von FFT-bezogenen Funktionen.

In Pocket speichern vorlesen Druckansicht 2 Kommentare lesen

(Bild: Peshkova/Shutterstock.com)

Lesezeit: 6 Min.
Von
  • Silke Hahn
Inhaltsverzeichnis

Die quelloffene Machine-Learning-Bibliothek PyTorch 1.7 ist erschienen, PyTorch unterstützt in der aktuellen Version Nvidias Programmierplattform CUDA 11. Das Release enthält eine Reihe neuer APIs, unterstützt mit NumPy kompatible FFT-Vorgänge (Fast Fourier Transform) – dieses Feature ist noch in der Betaphase – und bietet neue Profiling-Tools. So enthält die Bibliothek zur Verbesserung der Performance im Autograd-Profiler Ergänzungen für TorchScript und Stack Traces – damit sollen Nutzer Operatorennamen nicht nur in der Ausgabetabelle des Profilers sehen, sondern auch an der Stelle, wo der Operator sich im Code tatsächlich befindet.

An neuen Frontend-APIs umfasst PyTorch 1.7 torch.fft, ein Modul zum Implementieren von FFT-Funktionen, unterstützt C++ bei der nn.transformer-Modul-Abstraktion und kann mit torch.set_deterministic Operatoren steuern, die deterministische Algorithmen auswählen, sofern solche verfügbar sind. TorchElastic für das Bereitstellen strenger Obermengen in der torch.distributed.launch-CLI gilt nun als stabil und erhält weitere Funktionalitäten zur Erhöhung der Fehlertoleranz und Elastizität.

Bereits seit PyTorch 1.5 arbeitet das PyTorch-Team an den Frontend-APIs für C++: Seither bemühen sich die Entwickler um Parität zwischen den Python- und C++-APIs. Das aktuelle Release erlaubt es Entwicklern offenbar, die nn.transformer module abstraction aus dem C++-Frontend zu verwenden. Der Zwischenschritt des Ladens über Python/JIT entfällt, die Modulabstraktion lässt sich laut Blog-Ankündigung mit PyTorch 1.7 direkt in C++ umsetzen. Noch befindet sich die Entwicklung im Betastadium.

Weitere Neuerungen betreffen im Bereich mobiler Endgeräte Torchvision, das Tensor-Eingaben unterstützt und eine neue Video-API erhalten hat (noch in der Betaphase). Innerhalb dieses Features erbt transforms Eingaben nun vom nn.Module. Die Eingaben sollen sich in TorchScript umsetzen lassen und unterstützen laut BlogbBeitrag Tensoren mit Batch-Dimensionen, auch sollen sie nahtlos auf CPU/GPU-Geräten ausführbar sein, wie das PyTorch-Team mit einem Code-Beispiel veranschaulicht:

import torch
import torchvision.transforms as T

# to fix random seed, use torch.manual_seed
# instead of random.seed
torch.manual_seed(12)

transforms = torch.nn.Sequential(
T.RandomCrop(224),
T.RandomHorizontalFlip(p=0.3),
T.ConvertImageDtype(torch.float),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
)
scripted_transforms = torch.jit.script(transforms)
# Note: we can similarly use T.Compose to define transforms
# transforms = T.Compose([...]) and
# scripted_transforms = torch.jit.script(torch.nn.Sequential(*transforms.transforms))

tensor_image = torch.randint(0, 256, size=(3, 256, 256), dtype=torch.uint8)
# works directly on Tensors
out_image1 = transforms(tensor_image)
# on the GPU
out_image1_cuda = transforms(tensor_image.cuda())
# with batches
batched_image = torch.randint(0, 256, size=(4, 3, 256, 256), dtype=torch.uint8)
out_image_batched = transforms(batched_image)
# and has torchscript support
out_image2 = scripted_transforms(tensor_image)

Torchaudio soll mittlerweile Sprachaufnahmen (wav2letter) und die Sprachausgabe von Texten (WaveRNN) unterstützen.

Das PyTorch-Team hat das verteilte Training basierend auf DDP (Distributed Data Parallel) und RPC (Remote Procedure Call) offenbar grundlegend überarbeitet, erweitertes Training soll künftig auch auf Windows möglich sein (die Entwicklung ist noch im Prototyp-Stadium). Dass PyTorch verstärkt an der Unterstützung von Windows arbeitet, war bereits im letzten Release Kernthema. Einige bislang experimentelle Features wie benuterzdefinierte C++-Klassen, Erweiterungen mittels Tensor-ähnlichen Objekten und der Memory Profiler gelten jetzt als stabil. Seit dem letzten Release (1.6) klassifiziert das PyTorch-Team den Entwicklungsstand von Features als stabil, Beta oder Prototyp.

PyTorch 1.7 unterstützt DistributedDataParallel (DDP) und die kollekive Kommunikation auf der Windows-Plattform. Die Unterstützung im aktuellen Release betrifft insbesondere die ProcessGroup und den FileStore, die beide auf dem API-Gateway Gloo basieren. Um das als Prototyp bezeichnete Feature nutzen zu können, müssen Entwickler in der init_process_group eine Datei aus dem gemeinsamen Dateisystem bereitstellen. Wie das geht, führt das PyTorch-Team in seinem Blog vor:

# initialize the process group
dist.init_process_group(
"gloo",
# multi-machine example:
# init_method = "file://////{machine}/{share_folder}/file"
init_method="file:///{your local file path}",
rank=rank,
world_size=world_size
)

model = DistributedDataParallel(local_model, device_ids=[rank])

Zur Vertiefung können Interessierte auf GitHub ein Design-Dokument und auf der PyTorch-Website die Dokumentation konsultieren.

Das PyTorch-Team arbeitet neuerdings an Funktionalitäten, die historisch gesehen nur in geringem Grad von der ML-Bibliothek Unterstützung erfuhren: Die aktuelle Version von PyTorch erhält ein neues torch.fft-Modul, das zur Implementierung von FFT-Funktionen die gleiche API nutzt wie die Programmbibliothek NumPy für numerische Berechnungen in Python. Prozesse mit FFT (Fast Fourier Transforms) sind in wissenschaftlichen Gebieten beim Verarbeiten von Signalen geläufig. Laut Ankündigung im PyTorch-Blog ist das Importieren des Moduls unerlässlich, um PyTorch 1.7 nutzen zu können, da es sonst zu Namenskonflikten mit inzwischen als veraltet (deprecated) definierten Funktionen kommt.

Wie das in der Praxis ausschauen kann, dafür liefert das PyTorch-Team im Blog ein Code-Beispiel und verweist auf die ausführlichere Dokumentation:

>>> import torch.fft
>>> t = torch.arange(4)
>>> t
tensor([0, 1, 2, 3])

>>> torch.fft.fft(t)
tensor([ 6.+0.j, -2.+2.j, -2.+0.j, -2.-2.j])

>>> t = tensor([0.+1.j, 2.+3.j, 4.+5.j, 6.+7.j])
>>> torch.fft.fft(t)
tensor([12.+16.j, -8.+0.j, -4.-4.j, 0.-8.j])

Hinweise zu sämtlichen der zahlreichen Neuerungen und vertiefende Informationen lassen sich der Ankündigung im PyTorch-Blog entnehmen. Interessierte finden dort weiterführende Verlinkungen zur Dokumentation und zu den Download-Optionen. Alle Features sind gemäß den seit kurzem geltenden PyTorch-Konventionen als stabil, Beta oder Prototyp markiert.

(sih)