Pytorch - Katze

Pytorch ist ein Open-Source-Framework für die Python-Programmiersprache.

Ein Tensor ist ein mehrdimensionales Array, das zum Speichern von Daten verwendet wird. Um einen Tensor zu verwenden, müssen wir das Fackelmodul importieren.

Zum Erstellen eines Tensors ist die verwendete Methode Tensor ().

Syntax:

Fackel.Tensor (Daten)

Wobei Daten ein mehrdimensionales Array sind.

Fackel.Katze()

Verwenden Sie die Taschenlampe.Katze().

Syntax:

Fackel.cat ((Tensor_Object1, Tensor_Object2,…), dim)

Parameter:

1. Es dauert zwei oder mehr Tensoren als erster Parameter.
2. Wenn Dim = 0, sind die Tensoren verkettet Säulenweise. Wenn Dim = 1, sind die Tensoren verkettet Zeilen und was.

Beispiel 1:

In diesem Beispiel werden wir zwei eindimensionale Tensoren erstellen und sie über Zeilen mit der Taschenlampe verkettet.Katze()

#import Fackelmodul
Taschenlampe importieren
#Create 2 Tensoren
Data1 = Fackel.Tensor ([10,20,30,40,50])
Data2 = Taschenlampe.Tensor ([1,2,3,4,5])
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
#Cattenate zwei Tensoren
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Daten1, Daten2)))

Ausgang:

Tatsächliche Tensoren:
Tensor ([10, 20, 30, 40, 50])
Tensor ([1, 2, 3, 4, 5])
Verketteter Tensor: Tensor ([10, 20, 30, 40, 50, 1, 2, 3, 4, 5])

Zwei Tensoren werden horizontal verkettet (zeilenweise), da die Tensoren vom Typ 1 dimensional sind.

Beispiel 2:

In diesem Beispiel erstellen wir fünf eindimensionale Tensoren.Katze().

#import Fackelmodul
Taschenlampe importieren
#Create 5 Tensoren
Data1 = Fackel.Tensor ([10,20,40,50])
Data2 = Taschenlampe.Tensor ([2,3,4,5])
Data3 = Torch.Tensor ([12,45,67,89])
Data4 = Taschenlampe.Tensor ([100,32,45,67])
Data5 = Fackel.Tensor ([120.456,1,1])
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
drucken (Daten3)
Druck (Daten4)
Druck (Daten5)
#Cattenate zwei Tensoren
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Data1, Data2, Data3, Data4, Data5))))

Ausgang:

Tatsächliche Tensoren:
Tensor ([10, 20, 40, 50])
Tensor ([2, 3, 4, 5])
Tensor ([12, 45, 67, 89])
Tensor ([100, 32, 45, 67])
Tensor ([120, 456, 1, 1])
Verketteter Tensor: Tensor ([10, 20, 40, 50, 2, 3, 4, 5, 12, 45, 67, 89, 100, 32,
45, 67, 120, 456, 1, 1])

Fünf Tensoren werden horizontal (zeilweise) verkettet, da die Tensoren vom Typ 1 dimensional sind…

Beispiel 3:

In diesem Beispiel werden wir fünf zweidimensionale Tensoren erstellen und sie über Zeilen mit Taschenlampe verkettet.Katze().

#import Fackelmodul
Taschenlampe importieren
#create 5 Tensoren mit jeweils 2 Dimensionen
Data1 = Fackel.Tensor ([[10,20,40,50], [1,2,3,4]])
Data2 = Taschenlampe.Tensor ([[2,3,4,5], [20,70,89,0]])
Data3 = Torch.Tensor ([[12,4,5,6], [56,34,56,787]])
Data4 = Taschenlampe.Tensor ([[100,1,2,3], [67,87,6,78]])
Data5 = Fackel.Tensor ([[120,33,56,78], [45,56,78,6]])
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
drucken (Daten3)
Druck (Daten4)
Druck (Daten5)
#Concatenate -Tensoren über Zeilen
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Data1, Data2, Data3, Data4, Data5), Dim = 1))

Ausgang:

Tatsächliche Tensoren:
Tensor ([[10, 20, 40, 50],
[1, 2, 3, 4]])
Tensor ([[2, 3, 4, 5],
[20, 70, 89, 0]])
Tensor ([[12, 4, 5, 6],
[56, 34, 56, 787]])
Tensor ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Verketteter Tensor: Tensor ([[10, 20, 40, 50, 2, 3, 4, 5, 12, 4, 5, 6, 100, 1,
2, 3, 120, 33, 56, 78],
[1, 2, 3, 4, 20, 70, 89, 0, 56, 34, 56, 787, 67, 87,
6, 78, 45, 56, 78, 6]]))

Fünf Tensoren werden horizontal (zeilenweise) verkettet, wie wir Dim = 1 angegeben haben.

Beispiel 4:

In diesem Beispiel werden wir fünf zweidimensionale Tensoren erstellen und sie über Spalten mit Taschenlampe verkettet.Katze().

#import Fackelmodul
Taschenlampe importieren
#create 5 Tensoren mit jeweils 2 Dimensionen
Data1 = Fackel.Tensor ([[10,20,40,50], [1,2,3,4]])
Data2 = Taschenlampe.Tensor ([[2,3,4,5], [20,70,89,0]])
Data3 = Torch.Tensor ([[12,4,5,6], [56,34,56,787]])
Data4 = Taschenlampe.Tensor ([[100,1,2,3], [67,87,6,78]])
Data5 = Fackel.Tensor ([[120,33,56,78], [45,56,78,6]])
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
drucken (Daten3)
Druck (Daten4)
Druck (Daten5)
#Concatenate -Tensoren über Spalten
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Data1, Data2, Data3, Data4, Data5), Dim = 0))

Ausgang:

Tatsächliche Tensoren:
Tensor ([[10, 20, 40, 50],
[1, 2, 3, 4]])
Tensor ([[2, 3, 4, 5],
[20, 70, 89, 0]])
Tensor ([[12, 4, 5, 6],
[56, 34, 56, 787]])
Tensor ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Verketteter Tensor: Tensor ([[10, 20, 40, 50],
[1, 2, 3, 4],
[2, 3, 4, 5],
[20, 70, 89, 0],
[12, 4, 5, 6],
[56, 34, 56, 787],
[100, 1, 2, 3],
[67, 87, 6, 78],
[120, 33, 56, 78],
[45, 56, 78, 6]])

Fünf Tensoren werden vertikal (Spalten-) verkettet, wie wir dim = 0 angegeben haben.

Arbeiten Sie mit CPU

Wenn Sie eine CAT () -Funktion auf der CPU ausführen möchten, müssen wir einen Tensor mit einer CPU () -Funktion erstellen. Dies wird auf einer CPU -Maschine ausgeführt.

Zu diesem Zeitpunkt können wir beim Erstellen eines Tensors die CPU () -Funktion verwenden.

Syntax:
Fackel.Tensor (Daten).Zentralprozessor()

Beispiel 1:

In diesem Beispiel werden wir zwei eindimensionale Tensoren auf der CPU erstellen und sie über Zeilen mit Taschenlampe verkettet.Katze().

#import Fackelmodul
Taschenlampe importieren
#Create 2 Tensoren
Data1 = Fackel.Tensor ([10,20,30,40,50]).Zentralprozessor()
Data2 = Taschenlampe.Tensor ([1,2,3,4,5]).Zentralprozessor()
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
#Cattenate zwei Tensoren
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Daten1, Daten2)))

Ausgang:

Tatsächliche Tensoren:
Tensor ([10, 20, 30, 40, 50])
Tensor ([1, 2, 3, 4, 5])
Verketteter Tensor: Tensor ([10, 20, 30, 40, 50, 1, 2, 3, 4, 5])

Zwei Tensoren werden horizontal verkettet (zeilenweise), da die Tensoren vom Typ 1 dimensional sind.

Beispiel 2:

In diesem Beispiel werden wir fünf eindimensionale Tensoren auf der CPU erstellen und die Reihen mit Taschenlampe verkettet.Katze().

#import Fackelmodul
Taschenlampe importieren
#Create 5 Tensoren
Data1 = Fackel.Tensor ([10,20,40,50]).Zentralprozessor()
Data2 = Taschenlampe.Tensor ([2,3,4,5]).Zentralprozessor()
Data3 = Torch.Tensor ([12,45,67,89]).Zentralprozessor()
Data4 = Taschenlampe.Tensor ([100,32,45,67]).Zentralprozessor()
Data5 = Fackel.Tensor ([120.456,1,1]).Zentralprozessor()
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
drucken (Daten3)
Druck (Daten4)
Druck (Daten5)
#Cattenate zwei Tensoren
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Data1, Data2, Data3, Data4, Data5))))

Ausgang:

Tatsächliche Tensoren:
Tensor ([10, 20, 40, 50])
Tensor ([2, 3, 4, 5])
Tensor ([12, 45, 67, 89])
Tensor ([100, 32, 45, 67])
Tensor ([120, 456, 1, 1])
Verketteter Tensor: Tensor ([10, 20, 40, 50, 2, 3, 4, 5, 12, 45, 67, 89, 100, 32,
45, 67, 120, 456, 1, 1])

Fünf Tensoren sind horizontal verkettet (zeilenweise), da die Tensoren vom Typ 1 dimensional sind.

Beispiel 3:

In diesem Beispiel werden wir fünf zweidimensionale Tensoren auf der CPU erstellen und sie über Zeilen mit Taschenlampe verkettet.Katze().

#import Fackelmodul
Taschenlampe importieren
#create 5 Tensoren mit jeweils 2 Dimensionen
Data1 = Fackel.Tensor ([[10,20,40,50], [1,2,3,4]]).Zentralprozessor()
Data2 = Taschenlampe.Tensor ([[2,3,4,5], [20,70,89,0]]).Zentralprozessor()
Data3 = Torch.Tensor ([[12,4,5,6], [56,34,56,787]]).Zentralprozessor()
Data4 = Taschenlampe.Tensor ([[100,1,2,3], [67,87,6,78]]).Zentralprozessor()
Data5 = Fackel.Tensor ([[120,33,56,78], [45,56,78,6]]).Zentralprozessor()
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
drucken (Daten3)
Druck (Daten4)
Druck (Daten5)
#Concatenate -Tensoren über Zeilen
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Data1, Data2, Data3, Data4, Data5), Dim = 1))

Ausgang:

Tatsächliche Tensoren:
Tensor ([[10, 20, 40, 50],
[1, 2, 3, 4]])
Tensor ([[2, 3, 4, 5],
[20, 70, 89, 0]])
Tensor ([[12, 4, 5, 6],
[56, 34, 56, 787]])
Tensor ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Verketteter Tensor: Tensor ([[10, 20, 40, 50, 2, 3, 4, 5, 12, 4, 5, 6, 100, 1,
2, 3, 120, 33, 56, 78],
[1, 2, 3, 4, 20, 70, 89, 0, 56, 34, 56, 787, 67, 87,
6, 78, 45, 56, 78, 6]]))

Fünf Tensoren werden horizontal verkettet (Zeile0 in Bezug auf DIM = 1.

Beispiel 4:

In diesem Beispiel werden wir fünf zweidimensionale Tensoren auf der CPU erstellen und sie über Spalten mit Taschenlampe verkettet.Katze().

#import Fackelmodul
Taschenlampe importieren
#create 5 Tensoren mit jeweils 2 Dimensionen
Data1 = Fackel.Tensor ([[10,20,40,50], [1,2,3,4]]).Zentralprozessor()
Data2 = Taschenlampe.Tensor ([[2,3,4,5], [20,70,89,0]]).Zentralprozessor()
Data3 = Torch.Tensor ([[12,4,5,6], [56,34,56,787]]).Zentralprozessor()
Data4 = Taschenlampe.Tensor ([[100,1,2,3], [67,87,6,78]]).Zentralprozessor()
Data5 = Fackel.Tensor ([[120,33,56,78], [45,56,78,6]]).Zentralprozessor()
#Anzeige
print ("tatsächliche Tensoren:")
Druck (Daten1)
Druck (Daten2)
drucken (Daten3)
Druck (Daten4)
Druck (Daten5)
#Concatenate -Tensoren über Spalten
Druck ("verketteter Tensor:", Taschenlampe.CAT ((Data1, Data2, Data3, Data4, Data5), Dim = 0))

Ausgang:

Tatsächliche Tensoren:
Tensor ([[10, 20, 40, 50],
[1, 2, 3, 4]])
Tensor ([[2, 3, 4, 5],
[20, 70, 89, 0]])
Tensor ([[12, 4, 5, 6],
[56, 34, 56, 787]])
Tensor ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Verketteter Tensor: Tensor ([[10, 20, 40, 50],
[1, 2, 3, 4],
[2, 3, 4, 5],
[20, 70, 89, 0],
[12, 4, 5, 6],
[56, 34, 56, 787],
[100, 1, 2, 3],
[67, 87, 6, 78],
[120, 33, 56, 78],
[45, 56, 78, 6]])

Fünf Tensoren werden vertikal (Spalten-) verkettet, wie wir dim = 0 angegeben haben.

Abschluss

Wir haben gesehen, wie man zwei oder mehr Tensor. Wenn Dim = 0, sind die Tensoren verkettet Säulen; Wenn Dim = 1, sind die Tensoren verkettet Zeilen und was. In diesem Artikel haben wir mehrere Beispiele zur Verkettung eines und zweidimensionalen Tensoren implementieren und auch CAT () in der CPU mit der CPU () -Funktion implementieren.