Ang isa sa pinakamalaking bentahe ng mga tensor ay ang kanilang kakayahang magsagawa ng mahusay na mga operasyon sa matematika. Sinusuportahan ng mga tensor ang malawak na hanay ng mga pagpapatakbo ng aritmetika kabilang ang mga pagpapatakbong matalino sa elemento tulad ng pagdaragdag, pagbabawas, pagpaparami, at paghahati at ang mga pagpapatakbo ng matrix tulad ng pagpaparami at pag-transpose ng matrix.
Nagbibigay ang PyTorch ng komprehensibong hanay ng mga function at pamamaraan para sa pagmamanipula ng mga tensor. Kabilang dito ang mga operasyon para sa muling paghubog ng mga tensor, pagkuha ng mga partikular na elemento o sub-tensor, at pagsasama-sama o paghahati ng mga tensor sa mga tinukoy na dimensyon. Bukod pa rito, nag-aalok ang PyTorch ng mga functionality para sa pag-index, paghiwa, at pagsasahimpapawid ng mga tensor na nagpapadali sa paggana sa mga tensor na may iba't ibang hugis at laki.
Sa artikulong ito, malalaman natin ang mga pangunahing operasyon na may mga tensor sa PyTorch, tuklasin kung paano lumikha ng mga tensor, magsagawa ng mga pangunahing operasyon, manipulahin ang kanilang hugis, at ilipat ang mga ito sa pagitan ng CPU at GPU.
Paglikha ng mga Tensor
Ang mga tensor sa PyTorch ay maaaring malikha sa maraming paraan. Tuklasin natin ang ilang karaniwang pamamaraan.
Upang lumikha ng isang tensor, maaari naming gamitin ang 'torch.Tensor' na klase o ang 'torch.tensor' function. Tingnan natin ang ilang halimbawa:
angkat tanglaw
# Gumawa ng 1 - dimensional tensor mula sa isang listahan ng Python
tensor_1d = tanglaw. tensor ( [ 1 , 2 , 3 , 4 , 5 ] )
print ( tensor_1d )
# Gumawa ng 2 - dimensional tensor mula sa isang nested na listahan ng Python
tensor_2d = tanglaw. tensor ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
print ( tensor_2d )
# Lumikha ng tensor ng mga zero na may partikular na hugis
zeros_tensor = tanglaw. mga zero ( 3 , 2 )
print ( zeros_tensor )
# Lumikha ng isang tensor ng mga may isang tiyak na hugis
ones_tensor = tanglaw. mga ( 2 , 3 )
print ( ones_tensor )
# Lumikha ng isang tensor na may mga random na halaga mula sa isang pare-parehong pamamahagi
random_tensor = tanglaw. rand ( 2 , 2 )
print ( random_tensor )
Sa ibinigay na mga halimbawa, ginagawa namin ang mga tensor ng iba't ibang mga hugis at sinisimulan ang mga ito sa iba't ibang mga halaga tulad ng mga partikular na numero, mga zero, mga isa, o mga random na halaga. Dapat kang makakita ng katulad na output kapag pinatakbo mo ang nakaraang code snippet:
Mga Operasyon ng Tensor
Kapag mayroon na kaming mga tensor, maaari kaming magsagawa ng iba't ibang mga operasyon sa mga ito tulad ng mga pagpapatakbo ng arithmetic na matalino sa elemento, mga pagpapatakbo ng matrix, at higit pa.
Element-Wise Arithmetic Operations
Ang mga Element-wise arithmetic operations ay nagbibigay-daan sa amin na magsagawa ng mga computations sa pagitan ng mga tensor sa isang element-by-element na batayan. Ang mga tensor na kasangkot sa operasyon ay dapat magkaroon ng parehong hugis.
Narito ang ilang halimbawa:
angkat tanglaw# Lumikha ng mga tensor
tensor1 = tanglaw. tensor ( [ 1 , 2 , 3 ] )
tensor2 = tanglaw. tensor ( [ 4 , 5 , 6 ] )
# Dagdag
karagdagan = tensor1 + tensor2
print ( 'Dagdag:' , karagdagan )
# Pagbabawas
pagbabawas = tensor1 - tensor2
print ( 'Pagbabawas:' , pagbabawas )
# Multiplikasyon
pagpaparami = tensor1 * tensor2
print ( 'Pagpaparami:' , pagpaparami )
# Dibisyon
dibisyon = tensor1 / tensor2
print ( 'Dibisyon:' , dibisyon )
Sa ibinigay na code, ginagawa namin ang pagdaragdag, pagbabawas, pagpaparami, at paghahati ng mga operasyon sa pagitan ng dalawang tensor na nagreresulta sa isang bagong tensor na may mga nakalkulang halaga. Ang resulta ng snippet ng code ay ipinapakita tulad ng sumusunod:
Mga Pagpapatakbo ng Matrix
Nagbibigay ang PyTorch ng mahusay na mga operasyon ng matrix para sa mga tensor tulad ng pagpaparami ng matrix at transpose. Ang mga operasyong ito ay partikular na kapaki-pakinabang para sa mga gawain tulad ng linear algebra at neural network computations.
angkat tanglaw# Lumikha ng mga tensor
tensor1 = tanglaw. tensor ( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
tensor2 = tanglaw. tensor ( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
# Pagpaparami ng matrix
matrix_product = tanglaw. ang banig ( tensor1 , tensor2 )
print ( 'Produkto ng Matrix:' , matrix_product )
# Matrix transpose
matrix_transpose = tensor1. T
print ( 'Matrix Transpose:' , matrix_transpose )
Sa ibinigay na halimbawa, ginagawa namin ang multiplication ng matrix gamit ang function na 'torch.matmul' at makuha ang transpose ng isang matrix gamit ang attribute na '.T'.
Pagmamanipula ng Tensor Shape
Bilang karagdagan sa pagsasagawa ng mga operasyon sa mga tensor, madalas nating kailangang manipulahin ang kanilang hugis upang umangkop sa mga partikular na kinakailangan. Nagbibigay ang PyTorch ng ilang mga pag-andar upang muling hubugin ang mga tensor. Tuklasin natin ang ilan sa mga function na ito:
angkat tanglaw# Lumikha ng tensor
tensor = tanglaw. tensor ( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
# Baguhin ang hugis ng tensor
reshaped_tensor = tensor. muling hugis ( 3 , 2 )
print ( 'Muling Hugis Tensor:' , reshaped_tensor )
# Kunin ang laki ng isang tensor
laki = tensor. laki ( )
print ( 'Laki ng Tensor:' , laki )
# Kunin ang bilang ng mga elemento sa isang tensor
num_elements = tensor. magbigay ng pangalan ( )
print ( 'Bilang ng Elemento:' , num_elements )
Sa ibinigay na code, binabago namin ang isang tensor gamit ang function na reshape, kinukuha ang laki ng isang tensor gamit ang paraan ng laki, at nakukuha namin ang kabuuang bilang ng mga elemento sa isang tensor gamit ang paraan ng numel.
Paglipat ng mga Tensor sa Pagitan ng CPU at GPU
Ang PyTorch ay nagbibigay ng suporta para sa GPU acceleration na nagpapahintulot sa amin na magsagawa ng mga pagkalkula sa mga graphics card na maaaring makabuluhang mapabilis ang malalim na mga gawain sa pag-aaral sa pamamagitan ng pagpapababa ng mga oras ng pagsasanay. Maaari naming ilipat ang mga tensor sa pagitan ng CPU at GPU gamit ang 'to' na paraan.
Tandaan : Magagawa lang ito kung mayroon kang NVIDIA GPU na may CUDA sa iyong makina.
angkat tanglaw# Lumikha ng tensor sa CPU
tensor_cpu = tanglaw. tensor ( [ 1 , 2 , 3 ] )
# Suriin kung Available ang GPU
kung tanglaw. magkaiba . mayroon pa ( ) :
# Ilipat ang tensor sa GPU
tensor_gpu = tensor_cpu. sa ( 'iba' )
print ( 'Tensor sa GPU:' , tensor_gpu )
iba pa :
print ( 'Hindi available ang GPU.' )
Sa ibinigay na code, tinitingnan namin kung available ang isang GPU gamit ang torch.cuda.is_available(). Kung available ang isang GPU, inililipat namin ang tensor mula sa CPU patungo sa GPU gamit ang pamamaraang 'to' na may argumentong 'cuda'.
Konklusyon
Ang pag-unawa sa mga pangunahing operasyon ng tensor ay mahalaga para sa pagtatrabaho sa PyTorch at pagbuo ng mga modelo ng malalim na pag-aaral. Sa artikulong ito, ginalugad namin kung paano lumikha ng mga tensor, magsagawa ng mga pangunahing operasyon, manipulahin ang kanilang hugis, at ilipat ang mga ito sa pagitan ng CPU at GPU. Gamit ang kaalamang ito, maaari ka na ngayong magsimulang magtrabaho kasama ang mga tensor sa PyTorch, magsagawa ng mga pagkalkula, at bumuo ng mga sopistikadong modelo ng deep-learning. Ang mga tensor ay nagsisilbing pundasyon para sa representasyon at pagmamanipula ng data sa PyTorch na nagbibigay-daan sa iyong ilabas ang buong kapangyarihan nitong maraming gamit na framework sa machine-learning.