Een van de grootste voordelen van tensoren is hun vermogen om efficiënte wiskundige bewerkingen uit te voeren. Tensoren ondersteunen een breed scala aan rekenkundige bewerkingen, waaronder de elementaire bewerkingen zoals optellen, aftrekken, vermenigvuldigen en delen en de matrixbewerkingen zoals matrixvermenigvuldiging en transponeren.
PyTorch biedt een uitgebreide reeks functies en methoden voor het manipuleren van de tensoren. Deze omvatten bewerkingen voor het opnieuw vormgeven van de tensoren, het extraheren van specifieke elementen of sub-tensoren, en het aaneenschakelen of splitsen van de tensoren langs gespecificeerde dimensies. Bovendien biedt PyTorch functionaliteiten voor het indexeren, segmenteren en uitzenden van de tensoren, waardoor het gemakkelijker wordt om met tensoren van verschillende vormen en maten te werken.
In dit artikel zullen we de fundamentele bewerkingen met tensoren in PyTorch leren, onderzoeken hoe we tensoren kunnen maken, basisbewerkingen kunnen uitvoeren, hun vorm kunnen manipuleren en ze tussen CPU en GPU kunnen verplaatsen.
Tensoren creëren
Tensoren in PyTorch kunnen op verschillende manieren worden gemaakt. Laten we enkele veelvoorkomende methoden verkennen.
Om een tensor te maken, kunnen we de klasse “torch.Tensor” of de functie “torch.tensor” gebruiken. Laten we eens kijken naar enkele voorbeelden:
importeren fakkel
# Maak een 1 - dimensionale tensor uit een Python-lijst
tensor_1d = fakkel. tensor ( [ 1 , 2 , 3 , 4 , 5 ] )
afdrukken ( tensor_1d )
# Maak een 2 - dimensionale tensor uit een geneste Python-lijst
tensor_2d = fakkel. tensor ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
afdrukken ( tensor_2d )
# Maak een tensor van nullen met een specifieke vorm
nullen_tensor = fakkel. nullen ( 3 , 2 )
afdrukken ( nullen_tensor )
# Maak een tensor van enen met een specifieke vorm
degenen_tensor = fakkel. degenen ( 2 , 3 )
afdrukken ( degenen_tensor )
# Creëer een tensor met willekeurige waarden uit een uniforme verdeling
willekeurige_tensor = fakkel. rand ( 2 , 2 )
afdrukken ( willekeurige_tensor )
In de gegeven voorbeelden creëren we de tensoren van verschillende vormen en initialiseren we deze met verschillende waarden, zoals specifieke getallen, nullen, enen of willekeurige waarden. U zou een soortgelijke uitvoer moeten zien wanneer u het vorige codefragment uitvoert:
Tensoroperaties
Zodra we tensoren hebben, kunnen we er verschillende bewerkingen op uitvoeren, zoals elementaire rekenkundige bewerkingen, matrixbewerkingen en meer.
Elementaire rekenkundige bewerkingen
Elementgewijze rekenkundige bewerkingen stellen ons in staat om berekeningen tussen tensoren per element uit te voeren. De bij de operatie betrokken tensoren moeten dezelfde vorm hebben.
Hier zijn enkele voorbeelden:
importeren fakkel# Maak tensoren
tensor1 = fakkel. tensor ( [ 1 , 2 , 3 ] )
tensor2 = fakkel. tensor ( [ 4 , 5 , 6 ] )
# Toevoeging
toevoeging = tensor1 + tensor2
afdrukken ( 'Toevoeging:' , toevoeging )
# Aftrekken
aftrekken = tensor1 - tensor2
afdrukken ( 'Aftrekken:' , aftrekken )
# Vermenigvuldiging
vermenigvuldiging = tensor1 * tensor2
afdrukken ( 'Vermenigvuldiging:' , vermenigvuldiging )
# Divisie
divisie = tensor1 / tensor2
afdrukken ( 'Divisie:' , divisie )
In de gegeven code voeren we de bewerkingen optellen, aftrekken, vermenigvuldigen en delen uit tussen twee tensoren, wat resulteert in een nieuwe tensor met de berekende waarden. Het resultaat van het codefragment wordt als volgt weergegeven:
Matrixoperaties
PyTorch biedt efficiënte matrixbewerkingen voor tensoren zoals matrixvermenigvuldiging en transponering. Deze bewerkingen zijn met name handig voor taken als lineaire algebra en neurale netwerkberekeningen.
importeren fakkel# Maak tensoren
tensor1 = fakkel. tensor ( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
tensor2 = fakkel. tensor ( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
# Matrix vermenigvuldiging
matrix_product = fakkel. de mat ( tensor1 , tensor2 )
afdrukken ( 'Matrixproduct:' , matrix_product )
# Matrixtransponering
matrix_transponeren = tensor1. T
afdrukken ( 'Matrixtransponeren:' , matrix_transponeren )
In het gegeven voorbeeld voeren we de matrixvermenigvuldiging uit met behulp van de functie 'torch.matmul' en verkrijgen we de transpositie van een matrix met behulp van het attribuut '.T'.
Manipulatie van tensorvormen
Naast het uitvoeren van bewerkingen op tensoren, moeten we vaak hun vorm manipuleren om aan specifieke vereisten te voldoen. PyTorch biedt verschillende functies om de tensoren opnieuw vorm te geven. Laten we enkele van deze functies verkennen:
importeren fakkel# Maak een tensor
tensor = fakkel. tensor ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
# Geef de tensor een nieuwe vorm
hervormde_tensor = tensor. hervormen ( 3 , 2 )
afdrukken ( 'Hervormde Tensor:' , hervormde_tensor )
# Verkrijg de grootte van een tensor
maat = tensor. maat ( )
afdrukken ( 'Grootte van de tensor:' , maat )
# Verkrijg het aantal elementen in een tensor
aantal_elementen = tensor. geef naam ( )
afdrukken ( 'Aantal elementen:' , aantal_elementen )
In de meegeleverde code geven we een tensor een nieuwe vorm met behulp van de reshape-functie, halen we de grootte van een tensor op met behulp van de size-methode en verkrijgen we het totale aantal elementen in een tensor met behulp van de numel-methode.
Tensoren verplaatsen tussen CPU en GPU
PyTorch biedt ondersteuning voor GPU-versnelling, waardoor we berekeningen kunnen uitvoeren op grafische kaarten, wat de deep learning-taken aanzienlijk kan versnellen door de trainingstijd te verkorten. We kunnen de tensoren tussen de CPU en GPU verplaatsen met behulp van de 'naar' -methode.
Opmerking : dit kan alleen worden gedaan als u een NVIDIA GPU met CUDA op uw machine hebt.
importeren fakkel# Maak een tensor op de CPU
tensor_cpu = fakkel. tensor ( [ 1 , 2 , 3 ] )
# Rekening als GPU is beschikbaar
als fakkel. verschillend . is beschikbaar ( ) :
# Verplaats de tensor naar GPU
tensor_gpu = tensor_cpu. naar ( 'verschillend' )
afdrukken ( 'Tensor op GPU:' , tensor_gpu )
anders :
afdrukken ( 'GPU niet beschikbaar.' )
In de meegeleverde code controleren we of er een GPU beschikbaar is met torch.cuda.is_available(). Als er een GPU beschikbaar is, verplaatsen we de tensor van de CPU naar de GPU met behulp van de 'to' -methode met het 'cuda' -argument.
Conclusie
Het begrijpen van de fundamentele tensoroperaties is cruciaal voor het werken met PyTorch en het bouwen van de deep learning-modellen. In dit artikel hebben we onderzocht hoe je tensoren kunt maken, basisbewerkingen kunt uitvoeren, hun vorm kunt manipuleren en ze tussen CPU en GPU kunt verplaatsen. Gewapend met deze kennis kun je nu aan de slag met tensoren in PyTorch, berekeningen uitvoeren en geavanceerde deep-learning-modellen bouwen. Tensoren dienen als basis voor gegevensrepresentatie en -manipulatie in PyTorch, waardoor u de volledige kracht van dit veelzijdige machine-learning-framework kunt ontketenen.