Pytorch - chat

Pytorch est un cadre open source pour le langage de programmation Python.

Un tenseur est un tableau multidimensionnel utilisé pour stocker des données. Donc, pour utiliser un tenseur, nous devons importer le module de torche.

Pour créer un tenseur, la méthode utilisée est le tenseur ().

Syntaxe:

torche.tenseur (données)

Où les données sont un tableau multidimensionnel.

torche.chat()

Pour concaténer deux tenseurs ou plus par une ligne ou une colonne, utilisez la torche.chat().

Syntaxe:

torche.Cat ((Tensor_Object1, Tensor_Object2,…), Dim)

Paramètres:

1. Il prend deux tenseurs ou plus comme premier paramètre.
2. Si dim = 0, les tenseurs sont concaténés en ce qui concerne la colonne. Si dim = 1, les tenseurs sont concaténés en termes de ligne.

Exemple 1:

Dans cet exemple, nous créerons deux tenseurs unidimensionnels et les concaténerons par des lignes en utilisant la torche.chat()

Module de torche #mport
Importer une torche
#create 2 tenseurs
data1 = torche.Tensor ([10,20,30,40,50])
data2 = torche.tenseur ([1,2,3,4,5])
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
#Concaténate deux tenseurs
Imprimer ("Tensor concaténé:", torche.cat ((data1, data2)))

Sortir:

Tenseurs réels:
tenseur ([10, 20, 30, 40, 50])
tenseur ([1, 2, 3, 4, 5])
Tensor concaténé: tenseur ([10, 20, 30, 40, 50, 1, 2, 3, 4, 5])

Deux tenseurs sont concaténés horizontalement (en ligne) car les tenseurs sont de type 1 dimensionnel.

Exemple 2:

Dans cet exemple, nous créerons cinq tenseurs unidimensionnels et les concaténerons en ligne à l'aide de la torche.chat().

Module de torche #mport
Importer une torche
#Create 5 tenseurs
data1 = torche.tenseur ([10,20,40,50])
data2 = torche.tenseur ([2,3,4,5])
data3 = torche.Tensor ([12,45,67,89])
data4 = torche.Tensor ([100,32,45,67])
data5 = torche.Tensor ([120 456,1,1])
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
Imprimer (DATA3)
Imprimer (Data4)
Imprimer (DATA5)
#concaténate deux tenseurs
Imprimer ("Tensor concaténé:", torche.cat ((data1, data2, data3, data4, data5))))

Sortir:

Tenseurs réels:
tenseur ([10, 20, 40, 50])
tenseur ([2, 3, 4, 5])
Tensor ([12, 45, 67, 89])
tenseur ([100, 32, 45, 67])
tenseur ([120, 456, 1, 1])
Tensor concaténé: tenseur ([10, 20, 40, 50, 2, 3, 4, 5, 12, 45, 67, 89, 100, 32,
45, 67, 120, 456, 1, 1])

Cinq tenseurs sont concaténés horizontalement (en ligne) car les tenseurs sont de type 1 dimensionnel…

Exemple 3:

Dans cet exemple, nous créerons cinq tenseurs bidimensionnels et les concaténerons via des lignes à l'aide de la torche.chat().

Module de torche #mport
Importer une torche
#create 5 tenseurs avec 2 dimensions chacun
data1 = torche.Tensor ([[10,20,40,50], [1,2,3,4]]))
data2 = torche.Tensor ([[2,3,4,5], [20,70,89,0]]))
data3 = torche.Tensor ([[12,4,5,6], [56,34,56,787]]))
data4 = torche.Tensor ([[100,1,2,3], [67,87,6,78]])
data5 = torche.Tensor ([[120,33,56,78], [45,56,78,6]])
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
Imprimer (DATA3)
Imprimer (Data4)
Imprimer (DATA5)
#Concaténate Tensors via des lignes
Imprimer ("Tensor concaténé:", torche.Cat ((data1, data2, data3, data4, data5), dim = 1))

Sortir:

Tenseurs réels:
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]])
tenseur ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Tensor concaténé: tenseur ([[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]])

Cinq tenseurs sont concaténés horizontalement (au niveau de la ligne) car nous avons spécifié DIM = 1.

Exemple 4:

Dans cet exemple, nous créerons cinq tenseurs bidimensionnels et les concaténerons via des colonnes en utilisant la torche.chat().

Module de torche #mport
Importer une torche
#create 5 tenseurs avec 2 dimensions chacun
data1 = torche.Tensor ([[10,20,40,50], [1,2,3,4]]))
data2 = torche.Tensor ([[2,3,4,5], [20,70,89,0]]))
data3 = torche.Tensor ([[12,4,5,6], [56,34,56,787]]))
data4 = torche.Tensor ([[100,1,2,3], [67,87,6,78]])
data5 = torche.Tensor ([[120,33,56,78], [45,56,78,6]])
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
Imprimer (DATA3)
Imprimer (Data4)
Imprimer (DATA5)
#Concaténate Tensors via des colonnes
Imprimer ("Tensor concaténé:", torche.Cat ((data1, data2, data3, data4, data5), dim = 0))

Sortir:

Tenseurs réels:
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]])
tenseur ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Tensor concaténé: tenseur ([[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]])

Cinq tenseurs sont concaténés verticalement (en colonne) car nous avons spécifié DIM = 0.

Travailler avec le processeur

Si vous souhaitez exécuter une fonction CAT () sur le CPU, alors nous devons créer un tenseur avec une fonction CPU (). Cela fonctionnera sur une machine CPU.

Pour le moment, lorsque nous créons un tenseur, nous pouvons utiliser la fonction CPU ().

Syntaxe:
torche.tenseur (données).CPU()

Exemple 1:

Dans cet exemple, nous créerons deux tenseurs unidimensionnels sur le processeur et les concaténerons via des lignes en utilisant une torche.chat().

Module de torche #mport
Importer une torche
#create 2 tenseurs
data1 = torche.Tensor ([10,20,30,40,50]).CPU()
data2 = torche.tenseur ([1,2,3,4,5]).CPU()
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
#Concaténate deux tenseurs
Imprimer ("Tensor concaténé:", torche.cat ((data1, data2)))

Sortir:

Tenseurs réels:
tenseur ([10, 20, 30, 40, 50])
tenseur ([1, 2, 3, 4, 5])
Tensor concaténé: tenseur ([10, 20, 30, 40, 50, 1, 2, 3, 4, 5])

Deux tenseurs sont concaténés horizontalement (en ligne) car les tenseurs sont de type 1 dimensionnel.

Exemple 2:

Dans cet exemple, nous créerons cinq tenseurs unidimensionnels sur le processeur et concaténer la ligne à l'aide de la torche.chat().

Module de torche #mport
Importer une torche
#Create 5 tenseurs
data1 = torche.tenseur ([10,20,40,50]).CPU()
data2 = torche.tenseur ([2,3,4,5]).CPU()
data3 = torche.Tensor ([12,45,67,89]).CPU()
data4 = torche.Tensor ([100,32,45,67]).CPU()
data5 = torche.Tensor ([120 456,1,1]).CPU()
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
Imprimer (DATA3)
Imprimer (Data4)
Imprimer (DATA5)
#concaténate deux tenseurs
Imprimer ("Tensor concaténé:", torche.cat ((data1, data2, data3, data4, data5))))

Sortir:

Tenseurs réels:
tenseur ([10, 20, 40, 50])
tenseur ([2, 3, 4, 5])
Tensor ([12, 45, 67, 89])
tenseur ([100, 32, 45, 67])
tenseur ([120, 456, 1, 1])
Tensor concaténé: tenseur ([10, 20, 40, 50, 2, 3, 4, 5, 12, 45, 67, 89, 100, 32,
45, 67, 120, 456, 1, 1])

Cinq tenseurs sont concaténés horizontalement (en ligne) car les tenseurs sont de type 1 dimensionnel.

Exemple 3:

Dans cet exemple, nous créerons cinq tenseurs bidimensionnels sur le processeur et les concaténerons via des lignes en utilisant une torche.chat().

Module de torche #mport
Importer une torche
#create 5 tenseurs avec 2 dimensions chacun
data1 = torche.Tensor ([[10,20,40,50], [1,2,3,4]])).CPU()
data2 = torche.Tensor ([[2,3,4,5], [20,70,89,0]])).CPU()
data3 = torche.Tensor ([[12,4,5,6], [56,34,56,787]])).CPU()
data4 = torche.Tensor ([[100,1,2,3], [67,87,6,78]]).CPU()
data5 = torche.Tensor ([[120,33,56,78], [45,56,78,6]]).CPU()
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
Imprimer (DATA3)
Imprimer (Data4)
Imprimer (DATA5)
#Concaténate Tensors via des lignes
Imprimer ("Tensor concaténé:", torche.Cat ((data1, data2, data3, data4, data5), dim = 1))

Sortir:

Tenseurs réels:
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]])
tenseur ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Tensor concaténé: tenseur ([[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]])

Cinq tenseurs sont concaténés horizontalement (Row0-Wise) car nous avons spécifié DIM = 1.

Exemple 4:

Dans cet exemple, nous créerons cinq tenseurs bidimensionnels sur le CPU et les concaténerons via des colonnes en utilisant la torche.chat().

Module de torche #mport
Importer une torche
#create 5 tenseurs avec 2 dimensions chacun
data1 = torche.Tensor ([[10,20,40,50], [1,2,3,4]])).CPU()
data2 = torche.Tensor ([[2,3,4,5], [20,70,89,0]])).CPU()
data3 = torche.Tensor ([[12,4,5,6], [56,34,56,787]])).CPU()
data4 = torche.Tensor ([[100,1,2,3], [67,87,6,78]]).CPU()
data5 = torche.Tensor ([[120,33,56,78], [45,56,78,6]]).CPU()
#afficher
Imprimer ("Tenseurs réels:")
Imprimer (DATA1)
Imprimer (data2)
Imprimer (DATA3)
Imprimer (Data4)
Imprimer (DATA5)
#Concaténate Tensors via des colonnes
Imprimer ("Tensor concaténé:", torche.Cat ((data1, data2, data3, data4, data5), dim = 0))

Sortir:

Tenseurs réels:
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]])
tenseur ([[100, 1, 2, 3],
[67, 87, 6, 78]])
Tensor ([[120, 33, 56, 78],
[45, 56, 78, 6]])
Tensor concaténé: tenseur ([[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]])

Cinq tenseurs sont concaténés verticalement (en colonne) car nous avons spécifié DIM = 0.

Conclusion

Nous avons vu comment concaténer deux ou plusieurs tenseurs horizontalement et verticalement dans Pytorch en utilisant la fonction Cat (). Si dim = 0, les tenseurs sont concaténés en termes de colonne; Si dim = 1, les tenseurs sont concaténés en termes de ligne. Dans cet article, nous avons mis en œuvre plusieurs exemples pour concaténer les tenseurs à deux dimensions et avons également mis en œuvre CAT () sur le CPU à l'aide de la fonction CPU ().