Einer der größten Vorteile von Tensoren ist ihre Fähigkeit, effiziente mathematische Operationen durchzuführen. Tensoren unterstützen eine breite Palette arithmetischer Operationen, einschließlich elementweiser Operationen wie Addition, Subtraktion, Multiplikation und Division sowie Matrixoperationen wie Matrixmultiplikation und -transponierung.
PyTorch bietet einen umfassenden Satz an Funktionen und Methoden zur Manipulation der Tensoren. Dazu gehören Operationen zum Umformen der Tensoren, zum Extrahieren bestimmter Elemente oder Untertensoren sowie zum Verketten oder Aufteilen der Tensoren entlang bestimmter Dimensionen. Darüber hinaus bietet PyTorch Funktionen zum Indizieren, Schneiden und Senden der Tensoren, was die Arbeit mit Tensoren unterschiedlicher Form und Größe erleichtert.
In diesem Artikel lernen wir die grundlegenden Operationen mit Tensoren in PyTorch kennen, erkunden, wie man Tensoren erstellt, grundlegende Operationen durchführt, ihre Form manipuliert und sie zwischen CPU und GPU verschiebt.
Tensoren erstellen
Tensoren in PyTorch können auf verschiedene Arten erstellt werden. Lassen Sie uns einige gängige Methoden untersuchen.
Um einen Tensor zu erstellen, können wir die Klasse „torch.Tensor“ oder die Funktion „torch.tensor“ verwenden. Schauen wir uns einige Beispiele an:
importieren Fackel
# Ein ... kreieren 1 - Dimensionstensor aus einer Python-Liste
tensor_1d = Fackel. Tensor ( [ 1 , 2 , 3 , 4 , 5 ] )
drucken ( tensor_1d )
# Ein ... kreieren 2 - Dimensionstensor aus einer verschachtelten Python-Liste
tensor_2d = Fackel. Tensor ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
drucken ( tensor_2d )
# Erstellen Sie einen Nulltensor mit einer bestimmten Form
null_tensor = Fackel. Nullen ( 3 , 2 )
drucken ( null_tensor )
# Erstelle einen Einsen-Tensor mit einer bestimmten Form
one_tensor = Fackel. Einsen ( 2 , 3 )
drucken ( one_tensor )
# Erstellen Sie einen Tensor mit Zufallswerten aus einer Gleichverteilung
random_tensor = Fackel. Rand ( 2 , 2 )
drucken ( random_tensor )
In den angegebenen Beispielen erstellen wir Tensoren unterschiedlicher Form und initialisieren sie mit verschiedenen Werten wie bestimmten Zahlen, Nullen, Einsen oder Zufallswerten. Sie sollten eine ähnliche Ausgabe sehen, wenn Sie das vorherige Code-Snippet ausführen:
Tensoroperationen
Sobald wir Tensoren haben, können wir verschiedene Operationen an ihnen durchführen, z. B. elementweise arithmetische Operationen, Matrixoperationen und mehr.
Elementweise arithmetische Operationen
Elementweise arithmetische Operationen ermöglichen es uns, Berechnungen zwischen Tensoren Element für Element durchzuführen. Die an der Operation beteiligten Tensoren sollten die gleiche Form haben.
Hier sind einige Beispiele:
importieren Fackel# Tensoren erstellen
Tensor1 = Fackel. Tensor ( [ 1 , 2 , 3 ] )
Tensor2 = Fackel. Tensor ( [ 4 , 5 , 6 ] )
# Ergänzung
Zusatz = Tensor1 + Tensor2
drucken ( 'Zusatz:' , Zusatz )
# Subtraktion
Subtraktion = Tensor1 - Tensor2
drucken ( 'Subtraktion:' , Subtraktion )
# Multiplikation
Multiplikation = Tensor1 * Tensor2
drucken ( 'Multiplikation:' , Multiplikation )
# Aufteilung
Aufteilung = Tensor1 / Tensor2
drucken ( 'Aufteilung:' , Aufteilung )
Im angegebenen Code führen wir die Additions-, Subtraktions-, Multiplikations- und Divisionsoperationen zwischen zwei Tensoren durch, was zu einem neuen Tensor mit den berechneten Werten führt. Das Ergebnis des Codeausschnitts wird wie folgt angezeigt:
Matrixoperationen
PyTorch bietet effiziente Matrixoperationen für Tensoren wie Matrixmultiplikation und -transponierung. Diese Operationen sind besonders nützlich für Aufgaben wie lineare Algebra und Berechnungen neuronaler Netzwerke.
importieren Fackel# Tensoren erstellen
Tensor1 = Fackel. Tensor ( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
Tensor2 = Fackel. Tensor ( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
# Matrix-Multiplikation
Matrixprodukt = Fackel. die Matte ( Tensor1 , Tensor2 )
drucken ( „Matrixprodukt:“ , Matrixprodukt )
# Matrix transponieren
matrix_transpose = Tensor1. T
drucken ( „Matrixtransponierung:“ , matrix_transpose )
Im gegebenen Beispiel führen wir die Matrixmultiplikation mit der Funktion „torch.matmul“ durch und erhalten die Transponierte einer Matrix mit dem Attribut „.T“.
Manipulation der Tensorform
Zusätzlich zur Durchführung von Operationen an Tensoren müssen wir oft ihre Form manipulieren, um sie an bestimmte Anforderungen anzupassen. PyTorch bietet mehrere Funktionen zum Umformen der Tensoren. Sehen wir uns einige dieser Funktionen an:
importieren Fackel# Erstelle einen Tensor
Tensor = Fackel. Tensor ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
# Den Tensor umformen
umgeformter_tensor = Tensor. umformen ( 3 , 2 )
drucken ( „Umgestalteter Tensor:“ , umgeformter_tensor )
# Ermitteln Sie die Größe eines Tensors
Größe = Tensor. Größe ( )
drucken ( „Größe des Tensors:“ , Größe )
# Ermitteln Sie die Anzahl der Elemente In ein Tensor
num_elements = Tensor. Namen nennen ( )
drucken ( „Anzahl der Elemente:“ , num_elements )
Im bereitgestellten Code formen wir einen Tensor mit der Reshape-Funktion um, rufen die Größe eines Tensors mit der Size-Methode ab und ermitteln die Gesamtzahl der Elemente in einem Tensor mit der Numel-Methode.
Verschieben von Tensoren zwischen CPU und GPU
PyTorch bietet Unterstützung für GPU-Beschleunigung, die es uns ermöglicht, Berechnungen auf Grafikkarten durchzuführen, was die Deep-Learning-Aufgaben durch Verkürzung der Trainingszeiten erheblich beschleunigen kann. Mit der „to“-Methode können wir die Tensoren zwischen CPU und GPU verschieben.
Notiz : Dies ist nur möglich, wenn Sie eine NVIDIA-GPU mit CUDA auf Ihrem Computer haben.
importieren Fackel# Erstellen Sie einen Tensor auf der CPU
tensor_cpu = Fackel. Tensor ( [ 1 , 2 , 3 ] )
# Überprüfen Wenn GPU ist verfügbar
Wenn Fackel. anders . ist verfügbar ( ) :
# Verschieben Sie den Tensor zur GPU
tensor_gpu = tensor_cpu. Zu ( 'anders' )
drucken ( „Tensor auf GPU:“ , tensor_gpu )
anders :
drucken ( „GPU nicht verfügbar.“ )
Im bereitgestellten Code prüfen wir mithilfe von Torch.cuda.is_available(), ob eine GPU verfügbar ist. Wenn eine GPU verfügbar ist, verschieben wir den Tensor mithilfe der „to“-Methode mit dem „cuda“-Argument von der CPU zur GPU.
Abschluss
Das Verständnis der grundlegenden Tensoroperationen ist für die Arbeit mit PyTorch und die Erstellung der Deep-Learning-Modelle von entscheidender Bedeutung. In diesem Artikel haben wir untersucht, wie man Tensoren erstellt, grundlegende Operationen ausführt, ihre Form manipuliert und sie zwischen CPU und GPU verschiebt. Ausgestattet mit diesem Wissen können Sie jetzt mit Tensoren in PyTorch arbeiten, Berechnungen durchführen und anspruchsvolle Deep-Learning-Modelle erstellen. Tensoren dienen als Grundlage für die Datendarstellung und -bearbeitung in PyTorch, wodurch Sie die volle Leistungsfähigkeit dieses vielseitigen Frameworks für maschinelles Lernen nutzen können.