L’un des plus grands avantages des tenseurs est leur capacité à effectuer des opérations mathématiques efficaces. Les tenseurs prennent en charge un large éventail d'opérations arithmétiques, y compris les opérations élémentaires telles que l'addition, la soustraction, la multiplication et la division, ainsi que les opérations matricielles telles que la multiplication matricielle et la transposition.
PyTorch fournit un ensemble complet de fonctions et de méthodes pour manipuler les tenseurs. Celles-ci incluent des opérations pour remodeler les tenseurs, extraire des éléments ou sous-tenseurs spécifiques et concaténer ou diviser les tenseurs selon des dimensions spécifiées. De plus, PyTorch offre des fonctionnalités d'indexation, de découpage et de diffusion des tenseurs, ce qui facilite le travail avec des tenseurs de différentes formes et tailles.
Dans cet article, nous apprendrons les opérations fondamentales avec les tenseurs dans PyTorch, explorerons comment créer des tenseurs, effectuer des opérations de base, manipuler leur forme et les déplacer entre le CPU et le GPU.
Créer des tenseurs
Les tenseurs dans PyTorch peuvent être créés de plusieurs manières. Explorons quelques méthodes courantes.
Pour créer un tenseur, on peut utiliser la classe « torch.Tensor » ou la fonction « torch.tensor ». Regardons quelques exemples :
importer torche
# Créer un 1 - tenseur dimensionnel à partir d'une liste Python
tenseur_1d = torche. tenseur ( [ 1 , 2 , 3 , 4 , 5 ] )
imprimer ( tenseur_1d )
# Créer un 2 - tenseur dimensionnel à partir d'une liste Python imbriquée
tenseur_2d = torche. tenseur ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
imprimer ( tenseur_2d )
# Créer un tenseur de zéros avec une forme spécifique
zéros_tensor = torche. des zéros ( 3 , 2 )
imprimer ( zéros_tensor )
# Créer un tenseur de uns avec une forme spécifique
ones_tensor = torche. ceux ( 2 , 3 )
imprimer ( ones_tensor )
# Créer un tenseur avec des valeurs aléatoires à partir d'une distribution uniforme
tenseur_aléatoire = torche. rand ( 2 , 2 )
imprimer ( tenseur_aléatoire )
Dans les exemples donnés, nous créons des tenseurs de différentes formes et les initialisons avec diverses valeurs telles que des nombres spécifiques, des zéros, des uns ou des valeurs aléatoires. Vous devriez voir un résultat similaire lorsque vous exécutez l'extrait de code précédent :
Opérations tensorielles
Une fois que nous avons les tenseurs, nous pouvons effectuer diverses opérations sur eux, telles que les opérations arithmétiques par éléments, les opérations matricielles, etc.
Opérations arithmétiques par éléments
Les opérations arithmétiques élément par élément nous permettent d'effectuer des calculs entre tenseurs élément par élément. Les tenseurs impliqués dans l'opération doivent avoir la même forme.
Voici quelques exemples:
importer torche# Créer des tenseurs
tenseur1 = torche. tenseur ( [ 1 , 2 , 3 ] )
tenseur2 = torche. tenseur ( [ 4 , 5 , 6 ] )
# Ajout
ajout = tenseur1 + tenseur2
imprimer ( 'Ajout:' , ajout )
# Soustraction
soustraction = tenseur1 - tenseur2
imprimer ( 'Soustraction:' , soustraction )
#Multiplication
multiplication = tenseur1 * tenseur2
imprimer ( 'Multiplication:' , multiplication )
#Division
division = tenseur1 / tenseur2
imprimer ( 'Division:' , division )
Dans le code donné, nous effectuons les opérations d'addition, de soustraction, de multiplication et de division entre deux tenseurs, ce qui aboutit à un nouveau tenseur avec les valeurs calculées. Le résultat de l'extrait de code s'affiche comme suit :
Opérations matricielles
PyTorch fournit des opérations matricielles efficaces pour les tenseurs telles que la multiplication matricielle et la transposition. Ces opérations sont particulièrement utiles pour des tâches telles que l'algèbre linéaire et les calculs de réseaux neuronaux.
importer torche# Créer des tenseurs
tenseur1 = torche. tenseur ( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
tenseur2 = torche. tenseur ( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
# Multiplication matricielle
produit_matrice = torche. le paillasson ( tenseur1 , tenseur2 )
imprimer ( « Produit matriciel : » , produit_matrice )
# Transposition matricielle
matrice_transpose = tenseur1. T
imprimer ( « Transposition matricielle : » , matrice_transpose )
Dans l'exemple donné, nous effectuons la multiplication matricielle à l'aide de la fonction « torch.matmul » et obtenons la transposition d'une matrice à l'aide de l'attribut « .T ».
Manipulation de la forme du tenseur
En plus d'effectuer des opérations sur les tenseurs, nous devons souvent manipuler leur forme pour répondre à des exigences spécifiques. PyTorch fournit plusieurs fonctions pour remodeler les tenseurs. Explorons certaines de ces fonctions :
importer torche# Créer un tenseur
tenseur = torche. tenseur ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
# Remodeler le tenseur
reshape_tensor = tenseur. remodeler ( 3 , 2 )
imprimer ( « Tenseur remodelé : » , reshape_tensor )
# Récupère la taille d'un tenseur
taille = tenseur. taille ( )
imprimer ( « Taille du tenseur : » , taille )
# Obtenez le nombre d'éléments dans un tenseur
num_elements = tenseur. donner le nom ( )
imprimer ( 'Nombre d'éléments :' , num_elements )
Dans le code fourni, nous remodelons un tenseur à l'aide de la fonction reshape, récupérons la taille d'un tenseur à l'aide de la méthode size et obtenons le nombre total d'éléments dans un tenseur à l'aide de la méthode numel.
Déplacement des tenseurs entre CPU et GPU
PyTorch prend en charge l'accélération GPU qui nous permet d'effectuer des calculs sur des cartes graphiques, ce qui peut accélérer considérablement les tâches d'apprentissage en profondeur en réduisant les temps de formation. Nous pouvons déplacer les tenseurs entre le CPU et le GPU en utilisant la méthode « to ».
Note : Cela ne peut être fait que si vous disposez d'un GPU NVIDIA avec CUDA sur votre machine.
importer torche# Créer un tenseur sur CPU
tensor_cpu = torche. tenseur ( [ 1 , 2 , 3 ] )
# Vérifier si Le GPU est disponible
si torche. différent . est disponible ( ) :
# Déplacez le tenseur vers le GPU
tensor_gpu = tensor_cpu. à ( 'différent' )
imprimer ( 'Tenseur sur GPU :' , tensor_gpu )
autre :
imprimer ( 'GPU non disponible.' )
Dans le code fourni, nous vérifions si un GPU est disponible en utilisant torch.cuda.is_available(). Si un GPU est disponible, nous déplaçons le tenseur du CPU vers le GPU en utilisant la méthode « to » avec l'argument « cuda ».
Conclusion
Comprendre les opérations tensorielles fondamentales est crucial pour travailler avec PyTorch et créer les modèles d'apprentissage en profondeur. Dans cet article, nous avons exploré comment créer des tenseurs, effectuer des opérations de base, manipuler leur forme et les déplacer entre le CPU et le GPU. Fort de ces connaissances, vous pouvez désormais commencer à travailler avec des tenseurs dans PyTorch, effectuer des calculs et créer des modèles d'apprentissage en profondeur sophistiqués. Les tenseurs servent de base à la représentation et à la manipulation des données dans PyTorch, ce qui vous permet de libérer toute la puissance de ce cadre d'apprentissage automatique polyvalent.